1 
// GENERATED BY ISLE. DO NOT EDIT!
2 
//
3 
// Generated automatically from the instruction-selection DSL code in:
4 
// - src/prelude.isle
5 
// - src/prelude_opt.isle
6 
// - src/opts/arithmetic.isle
7 
// - src/opts/bitops.isle
8 
// - src/opts/cprop.isle
9 
// - src/opts/extends.isle
10 
// - src/opts/icmp.isle
11 
// - src/opts/remat.isle
12 
// - src/opts/selects.isle
13 
// - src/opts/shifts.isle
14 
// - src/opts/vector.isle
15 
// - /home/smcdev/zk-client-private/near/target/debug/build/cranelift-codegen-c1a82fb675b6a305/out/clif_opt.isle
16 

            

        

            

                17
            

            

                
            

            

                
use super::*; // Pulls in all external types.

            

        

            

                18
            

            

                
            

            

                
use std::marker::PhantomData;

            

        

            

                19
            

            

                
            

            

                

            

        

            

                20
            

            

                
            

            

                
/// Context during lowering: an implementation of this trait

            

        

            

                21
            

            

                
            

            

                
/// must be provided with all external constructors and extractors.

            

        

            

                22
            

            

                
            

            

                
/// A mutable borrow is passed along through all lowering logic.

            

        

            

                23
            

            

                
            

            

                
pub trait Context {

            

        

            

                24
            

            

                
            

            

                
    fn unit(&mut self) -> Unit;

            

        

            

                25
            

            

                
            

            

                
    fn value_type(&mut self, arg0: Value) -> Type;

            

        

            

                26
            

            

                
            

            

                
    fn u32_nonnegative(&mut self, arg0: u32) -> Option<u32>;

            

        

            

                27
            

            

                
            

            

                
    fn offset32(&mut self, arg0: Offset32) -> i32;

            

        

            

                28
            

            

                
            

            

                
    fn u32_lteq(&mut self, arg0: u32, arg1: u32) -> Option<Unit>;

            

        

            

                29
            

            

                
            

            

                
    fn u8_lteq(&mut self, arg0: u8, arg1: u8) -> Option<Unit>;

            

        

            

                30
            

            

                
            

            

                
    fn u8_lt(&mut self, arg0: u8, arg1: u8) -> Option<Unit>;

            

        

            

                31
            

            

                
            

            

                
    fn simm32(&mut self, arg0: Imm64) -> Option<i32>;

            

        

            

                32
            

            

                
            

            

                
    fn uimm8(&mut self, arg0: Imm64) -> Option<u8>;

            

        

            

                33
            

            

                
            

            

                
    fn u8_as_i8(&mut self, arg0: u8) -> i8;

            

        

            

                34
            

            

                
            

            

                
    fn u8_as_u32(&mut self, arg0: u8) -> u32;

            

        

            

                35
            

            

                
            

            

                
    fn u8_as_u64(&mut self, arg0: u8) -> u64;

            

        

            

                36
            

            

                
            

            

                
    fn u16_as_u64(&mut self, arg0: u16) -> u64;

            

        

            

                37
            

            

                
            

            

                
    fn u32_as_u64(&mut self, arg0: u32) -> u64;

            

        

            

                38
            

            

                
            

            

                
    fn i32_as_i64(&mut self, arg0: i32) -> i64;

            

        

            

                39
            

            

                
            

            

                
    fn i64_as_u64(&mut self, arg0: i64) -> u64;

            

        

            

                40
            

            

                
            

            

                
    fn i64_neg(&mut self, arg0: i64) -> i64;

            

        

            

                41
            

            

                
            

            

                
    fn u128_as_u64(&mut self, arg0: u128) -> Option<u64>;

            

        

            

                42
            

            

                
            

            

                
    fn u64_as_u32(&mut self, arg0: u64) -> Option<u32>;

            

        

            

                43
            

            

                
            

            

                
    fn u64_as_i32(&mut self, arg0: u64) -> i32;

            

        

            

                44
            

            

                
            

            

                
    fn u8_and(&mut self, arg0: u8, arg1: u8) -> u8;

            

        

            

                45
            

            

                
            

            

                
    fn u8_shl(&mut self, arg0: u8, arg1: u8) -> u8;

            

        

            

                46
            

            

                
            

            

                
    fn u8_shr(&mut self, arg0: u8, arg1: u8) -> u8;

            

        

            

                47
            

            

                
            

            

                
    fn u8_sub(&mut self, arg0: u8, arg1: u8) -> u8;

            

        

            

                48
            

            

                
            

            

                
    fn u32_add(&mut self, arg0: u32, arg1: u32) -> u32;

            

        

            

                49
            

            

                
            

            

                
    fn u32_sub(&mut self, arg0: u32, arg1: u32) -> u32;

            

        

            

                50
            

            

                
            

            

                
    fn u32_and(&mut self, arg0: u32, arg1: u32) -> u32;

            

        

            

                51
            

            

                
            

            

                
    fn s32_add_fallible(&mut self, arg0: i32, arg1: i32) -> Option<i32>;

            

        

            

                52
            

            

                
            

            

                
    fn u64_add(&mut self, arg0: u64, arg1: u64) -> u64;

            

        

            

                53
            

            

                
            

            

                
    fn u64_sub(&mut self, arg0: u64, arg1: u64) -> u64;

            

        

            

                54
            

            

                
            

            

                
    fn u64_mul(&mut self, arg0: u64, arg1: u64) -> u64;

            

        

            

                55
            

            

                
            

            

                
    fn u64_sdiv(&mut self, arg0: u64, arg1: u64) -> Option<u64>;

            

        

            

                56
            

            

                
            

            

                
    fn u64_udiv(&mut self, arg0: u64, arg1: u64) -> Option<u64>;

            

        

            

                57
            

            

                
            

            

                
    fn u64_and(&mut self, arg0: u64, arg1: u64) -> u64;

            

        

            

                58
            

            

                
            

            

                
    fn u64_or(&mut self, arg0: u64, arg1: u64) -> u64;

            

        

            

                59
            

            

                
            

            

                
    fn u64_xor(&mut self, arg0: u64, arg1: u64) -> u64;

            

        

            

                60
            

            

                
            

            

                
    fn u64_shl(&mut self, arg0: u64, arg1: u64) -> u64;

            

        

            

                61
            

            

                
            

            

                
    fn imm64_shl(&mut self, arg0: Type, arg1: Imm64, arg2: Imm64) -> Imm64;

            

        

            

                62
            

            

                
            

            

                
    fn imm64_ushr(&mut self, arg0: Type, arg1: Imm64, arg2: Imm64) -> Imm64;

            

        

            

                63
            

            

                
            

            

                
    fn imm64_sshr(&mut self, arg0: Type, arg1: Imm64, arg2: Imm64) -> Imm64;

            

        

            

                64
            

            

                
            

            

                
    fn u64_not(&mut self, arg0: u64) -> u64;

            

        

            

                65
            

            

                
            

            

                
    fn u64_eq(&mut self, arg0: u64, arg1: u64) -> bool;

            

        

            

                66
            

            

                
            

            

                
    fn u64_le(&mut self, arg0: u64, arg1: u64) -> bool;

            

        

            

                67
            

            

                
            

            

                
    fn u64_lt(&mut self, arg0: u64, arg1: u64) -> bool;

            

        

            

                68
            

            

                
            

            

                
    fn i64_shr(&mut self, arg0: i64, arg1: i64) -> i64;

            

        

            

                69
            

            

                
            

            

                
    fn i64_ctz(&mut self, arg0: i64) -> i64;

            

        

            

                70
            

            

                
            

            

                
    fn i64_sextend_u64(&mut self, arg0: Type, arg1: u64) -> i64;

            

        

            

                71
            

            

                
            

            

                
    fn i64_sextend_imm64(&mut self, arg0: Type, arg1: Imm64) -> i64;

            

        

            

                72
            

            

                
            

            

                
    fn u64_uextend_imm64(&mut self, arg0: Type, arg1: Imm64) -> u64;

            

        

            

                73
            

            

                
            

            

                
    fn imm64_icmp(&mut self, arg0: Type, arg1: &IntCC, arg2: Imm64, arg3: Imm64) -> Imm64;

            

        

            

                74
            

            

                
            

            

                
    fn u64_is_zero(&mut self, arg0: u64) -> bool;

            

        

            

                75
            

            

                
            

            

                
    fn u64_is_odd(&mut self, arg0: u64) -> bool;

            

        

            

                76
            

            

                
            

            

                
    fn u128_replicated_u64(&mut self, arg0: u128) -> Option<u64>;

            

        

            

                77
            

            

                
            

            

                
    fn u64_replicated_u32(&mut self, arg0: u64) -> Option<u64>;

            

        

            

                78
            

            

                
            

            

                
    fn u32_replicated_u16(&mut self, arg0: u64) -> Option<u64>;

            

        

            

                79
            

            

                
            

            

                
    fn u16_replicated_u8(&mut self, arg0: u64) -> Option<u8>;

            

        

            

                80
            

            

                
            

            

                
    fn ty_umin(&mut self, arg0: Type) -> u64;

            

        

            

                81
            

            

                
            

            

                
    fn ty_umax(&mut self, arg0: Type) -> u64;

            

        

            

                82
            

            

                
            

            

                
    fn ty_smin(&mut self, arg0: Type) -> u64;

            

        

            

                83
            

            

                
            

            

                
    fn ty_smax(&mut self, arg0: Type) -> u64;

            

        

            

                84
            

            

                
            

            

                
    fn ty_bits(&mut self, arg0: Type) -> u8;

            

        

            

                85
            

            

                
            

            

                
    fn ty_bits_u16(&mut self, arg0: Type) -> u16;

            

        

            

                86
            

            

                
            

            

                
    fn ty_bits_u64(&mut self, arg0: Type) -> u64;

            

        

            

                87
            

            

                
            

            

                
    fn ty_mask(&mut self, arg0: Type) -> u64;

            

        

            

                88
            

            

                
            

            

                
    fn ty_lane_mask(&mut self, arg0: Type) -> u64;

            

        

            

                89
            

            

                
            

            

                
    fn ty_lane_count(&mut self, arg0: Type) -> u64;

            

        

            

                90
            

            

                
            

            

                
    fn ty_bytes(&mut self, arg0: Type) -> u16;

            

        

            

                91
            

            

                
            

            

                
    fn lane_type(&mut self, arg0: Type) -> Type;

            

        

            

                92
            

            

                
            

            

                
    fn ty_half_lanes(&mut self, arg0: Type) -> Option<Type>;

            

        

            

                93
            

            

                
            

            

                
    fn ty_half_width(&mut self, arg0: Type) -> Option<Type>;

            

        

            

                94
            

            

                
            

            

                
    fn ty_equal(&mut self, arg0: Type, arg1: Type) -> bool;

            

        

            

                95
            

            

                
            

            

                
    fn mem_flags_trusted(&mut self) -> MemFlags;

            

        

            

                96
            

            

                
            

            

                
    fn intcc_swap_args(&mut self, arg0: &IntCC) -> IntCC;

            

        

            

                97
            

            

                
            

            

                
    fn intcc_complement(&mut self, arg0: &IntCC) -> IntCC;

            

        

            

                98
            

            

                
            

            

                
    fn intcc_without_eq(&mut self, arg0: &IntCC) -> IntCC;

            

        

            

                99
            

            

                
            

            

                
    fn floatcc_swap_args(&mut self, arg0: &FloatCC) -> FloatCC;

            

        

            

                100
            

            

                
            

            

                
    fn floatcc_complement(&mut self, arg0: &FloatCC) -> FloatCC;

            

        

            

                101
            

            

                
            

            

                
    fn floatcc_unordered(&mut self, arg0: &FloatCC) -> bool;

            

        

            

                102
            

            

                
            

            

                
    fn fits_in_16(&mut self, arg0: Type) -> Option<Type>;

            

        

            

                103
            

            

                
            

            

                
    fn fits_in_32(&mut self, arg0: Type) -> Option<Type>;

            

        

            

                104
            

            

                
            

            

                
    fn lane_fits_in_32(&mut self, arg0: Type) -> Option<Type>;

            

        

            

                105
            

            

                
            

            

                
    fn fits_in_64(&mut self, arg0: Type) -> Option<Type>;

            

        

            

                106
            

            

                
            

            

                
    fn ty_32(&mut self, arg0: Type) -> Option<Type>;

            

        

            

                107
            

            

                
            

            

                
    fn ty_64(&mut self, arg0: Type) -> Option<Type>;

            

        

            

                108
            

            

                
            

            

                
    fn ty_int_ref_scalar_64_extract(&mut self, arg0: Type) -> Option<Type>;

            

        

            

                109
            

            

                
            

            

                
    fn ty_int_ref_scalar_64(&mut self, arg0: Type) -> Option<Type>;

            

        

            

                110
            

            

                
            

            

                
    fn ty_32_or_64(&mut self, arg0: Type) -> Option<Type>;

            

        

            

                111
            

            

                
            

            

                
    fn ty_8_or_16(&mut self, arg0: Type) -> Option<Type>;

            

        

            

                112
            

            

                
            

            

                
    fn int_fits_in_32(&mut self, arg0: Type) -> Option<Type>;

            

        

            

                113
            

            

                
            

            

                
    fn ty_int_ref_64(&mut self, arg0: Type) -> Option<Type>;

            

        

            

                114
            

            

                
            

            

                
    fn ty_int_ref_16_to_64(&mut self, arg0: Type) -> Option<Type>;

            

        

            

                115
            

            

                
            

            

                
    fn ty_int(&mut self, arg0: Type) -> Option<Type>;

            

        

            

                116
            

            

                
            

            

                
    fn ty_scalar(&mut self, arg0: Type) -> Option<Type>;

            

        

            

                117
            

            

                
            

            

                
    fn ty_scalar_float(&mut self, arg0: Type) -> Option<Type>;

            

        

            

                118
            

            

                
            

            

                
    fn ty_float_or_vec(&mut self, arg0: Type) -> Option<Type>;

            

        

            

                119
            

            

                
            

            

                
    fn ty_vector_float(&mut self, arg0: Type) -> Option<Type>;

            

        

            

                120
            

            

                
            

            

                
    fn ty_vector_not_float(&mut self, arg0: Type) -> Option<Type>;

            

        

            

                121
            

            

                
            

            

                
    fn ty_vec64(&mut self, arg0: Type) -> Option<Type>;

            

        

            

                122
            

            

                
            

            

                
    fn ty_vec64_ctor(&mut self, arg0: Type) -> Option<Type>;

            

        

            

                123
            

            

                
            

            

                
    fn ty_vec128(&mut self, arg0: Type) -> Option<Type>;

            

        

            

                124
            

            

                
            

            

                
    fn ty_dyn_vec64(&mut self, arg0: Type) -> Option<Type>;

            

        

            

                125
            

            

                
            

            

                
    fn ty_dyn_vec128(&mut self, arg0: Type) -> Option<Type>;

            

        

            

                126
            

            

                
            

            

                
    fn ty_vec64_int(&mut self, arg0: Type) -> Option<Type>;

            

        

            

                127
            

            

                
            

            

                
    fn ty_vec128_int(&mut self, arg0: Type) -> Option<Type>;

            

        

            

                128
            

            

                
            

            

                
    fn ty_addr64(&mut self, arg0: Type) -> Option<Type>;

            

        

            

                129
            

            

                
            

            

                
    fn not_vec32x2(&mut self, arg0: Type) -> Option<Type>;

            

        

            

                130
            

            

                
            

            

                
    fn not_i64x2(&mut self, arg0: Type) -> Option<()>;

            

        

            

                131
            

            

                
            

            

                
    fn u8_from_uimm8(&mut self, arg0: Uimm8) -> u8;

            

        

            

                132
            

            

                
            

            

                
    fn u64_from_bool(&mut self, arg0: bool) -> u64;

            

        

            

                133
            

            

                
            

            

                
    fn u64_from_imm64(&mut self, arg0: Imm64) -> u64;

            

        

            

                134
            

            

                
            

            

                
    fn nonzero_u64_from_imm64(&mut self, arg0: Imm64) -> Option<u64>;

            

        

            

                135
            

            

                
            

            

                
    fn imm64_power_of_two(&mut self, arg0: Imm64) -> Option<u64>;

            

        

            

                136
            

            

                
            

            

                
    fn imm64(&mut self, arg0: u64) -> Imm64;

            

        

            

                137
            

            

                
            

            

                
    fn imm64_masked(&mut self, arg0: Type, arg1: u64) -> Imm64;

            

        

            

                138
            

            

                
            

            

                
    fn u32_from_ieee32(&mut self, arg0: Ieee32) -> u32;

            

        

            

                139
            

            

                
            

            

                
    fn u64_from_ieee64(&mut self, arg0: Ieee64) -> u64;

            

        

            

                140
            

            

                
            

            

                
    fn multi_lane(&mut self, arg0: Type) -> Option<(u32, u32)>;

            

        

            

                141
            

            

                
            

            

                
    fn dynamic_lane(&mut self, arg0: Type) -> Option<(u32, u32)>;

            

        

            

                142
            

            

                
            

            

                
    fn dynamic_int_lane(&mut self, arg0: Type) -> Option<u32>;

            

        

            

                143
            

            

                
            

            

                
    fn dynamic_fp_lane(&mut self, arg0: Type) -> Option<u32>;

            

        

            

                144
            

            

                
            

            

                
    fn ty_dyn64_int(&mut self, arg0: Type) -> Option<Type>;

            

        

            

                145
            

            

                
            

            

                
    fn ty_dyn128_int(&mut self, arg0: Type) -> Option<Type>;

            

        

            

                146
            

            

                
            

            

                
    fn offset32_to_i32(&mut self, arg0: Offset32) -> i32;

            

        

            

                147
            

            

                
            

            

                
    fn i32_to_offset32(&mut self, arg0: i32) -> Offset32;

            

        

            

                148
            

            

                
            

            

                
    fn intcc_unsigned(&mut self, arg0: &IntCC) -> IntCC;

            

        

            

                149
            

            

                
            

            

                
    fn signed_cond_code(&mut self, arg0: &IntCC) -> Option<IntCC>;

            

        

            

                150
            

            

                
            

            

                
    fn trap_code_division_by_zero(&mut self) -> TrapCode;

            

        

            

                151
            

            

                
            

            

                
    fn trap_code_integer_overflow(&mut self) -> TrapCode;

            

        

            

                152
            

            

                
            

            

                
    fn trap_code_bad_conversion_to_integer(&mut self) -> TrapCode;

            

        

            

                153
            

            

                
            

            

                
    fn range(&mut self, arg0: usize, arg1: usize) -> Range;

            

        

            

                154
            

            

                
            

            

                
    fn range_view(&mut self, arg0: Range) -> RangeView;

            

        

            

                155
            

            

                
            

            

                
    type inst_data_etor_iter: ContextIter<Context = Self, Output = (Type, InstructionData)>;

            

        

            

                156
            

            

                
            

            

                
    fn inst_data_etor(&mut self, arg0: Value) -> Self::inst_data_etor_iter;

            

        

            

                157
            

            

                
            

            

                
    fn make_inst_ctor(&mut self, arg0: Type, arg1: &InstructionData) -> Value;

            

        

            

                158
            

            

                
            

            

                
    fn value_array_2_ctor(&mut self, arg0: Value, arg1: Value) -> ValueArray2;

            

        

            

                159
            

            

                
            

            

                
    fn value_array_3_ctor(&mut self, arg0: Value, arg1: Value, arg2: Value) -> ValueArray3;

            

        

            

                160
            

            

                
            

            

                
    fn remat(&mut self, arg0: Value) -> Value;

            

        

            

                161
            

            

                
            

            

                
    fn subsume(&mut self, arg0: Value) -> Value;

            

        

            

                162
            

            

                
            

            

                
    fn splat64(&mut self, arg0: u64) -> Constant;

            

        

            

                163
            

            

                
            

            

                
    fn unpack_value_array_2(&mut self, arg0: &ValueArray2) -> (Value, Value);

            

        

            

                164
            

            

                
            

            

                
    fn pack_value_array_2(&mut self, arg0: Value, arg1: Value) -> ValueArray2;

            

        

            

                165
            

            

                
            

            

                
    fn unpack_value_array_3(&mut self, arg0: &ValueArray3) -> (Value, Value, Value);

            

        

            

                166
            

            

                
            

            

                
    fn pack_value_array_3(&mut self, arg0: Value, arg1: Value, arg2: Value) -> ValueArray3;

            

        

            

                167
            

            

                
            

            

                
    fn unpack_block_array_2(&mut self, arg0: &BlockArray2) -> (BlockCall, BlockCall);

            

        

            

                168
            

            

                
            

            

                
    fn pack_block_array_2(&mut self, arg0: BlockCall, arg1: BlockCall) -> BlockArray2;

            

        

            

                169
            

            

                
            

            

                
}

            

        

            

                170
            

            

                
            

            

                

            

        

            

                171
            

            

                
            

            

                
pub trait ContextIter {

            

        

            

                172
            

            

                
            

            

                
    type Context;

            

        

            

                173
            

            

                
            

            

                
    type Output;

            

        

            

                174
            

            

                
            

            

                
    fn next(&mut self, ctx: &mut Self::Context) -> Option<Self::Output>;

            

        

            

                175
            

            

                
            

            

                
}

            

        

            

                176
            

            

                
            

            

                

            

        

            

                177
            

            

                
            

            

                
pub struct ContextIterWrapper<Item, I: Iterator<Item = Item>, C: Context> {

            

        

            

                178
            

            

                
            

            

                
    iter: I,

            

        

            

                179
            

            

                
            

            

                
    _ctx: PhantomData<C>,

            

        

            

                180
            

            

                
            

            

                
}

            

        

            

                181
            

            

                
            

            

                
impl<Item, I: Iterator<Item = Item>, C: Context> From<I> for ContextIterWrapper<Item, I, C> {

            

        

            

                182
            

            

                
            

            

                
    fn from(iter: I) -> Self {

            

        

            

                183
            

            

                
            

            

                
        Self {

            

        

            

                184
            

            

                
            

            

                
            iter,

            

        

            

                185
            

            

                
            

            

                
            _ctx: PhantomData,

            

        

            

                186
            

            

                
            

            

                
        }

            

        

            

                187
            

            

                
            

            

                
    }

            

        

            

                188
            

            

                
            

            

                
}

            

        

            

                189
            

            

                
            

            

                
impl<Item, I: Iterator<Item = Item>, C: Context> ContextIter for ContextIterWrapper<Item, I, C> {

            

        

            

                190
            

            

                
            

            

                
    type Context = C;

            

        

            

                191
            

            

                
            

            

                
    type Output = Item;

            

        

            

                192
            

            

                
            

            

                
    fn next(&mut self, _ctx: &mut Self::Context) -> Option<Self::Output> {

            

        

            

                193
            

            

                
            

            

                
        self.iter.next()

            

        

            

                194
            

            

                
            

            

                
    }

            

        

            

                195
            

            

                
            

            

                
}

            

        

            

                196
            

            

                
            

            

                

            

        

            

                197
            

            

                
            

            

                
// Generated as internal constructor for term eq.

            

        

            

                198
            

            

                
            

            

                
pub fn constructor_eq<C: Context>(ctx: &mut C, arg0: Type, arg1: Value, arg2: Value) -> Value {

            

        

            

                199
            

            

                
            

            

                
    let v4 = constructor_icmp(ctx, arg0, &IntCC::Equal, arg1, arg2);

            

        

            

                200
            

            

                
            

            

                
    // Rule at src/prelude_opt.isle line 20.

            

        

            

                201
            

            

                
            

            

                
    return v4;

            

        

            

                202
            

            

                
            

            

                
}

            

        

            

                203
            

            

                
            

            

                

            

        

            

                204
            

            

                
            

            

                
// Generated as internal constructor for term ne.

            

        

            

                205
            

            

                
            

            

                
pub fn constructor_ne<C: Context>(ctx: &mut C, arg0: Type, arg1: Value, arg2: Value) -> Value {

            

        

            

                206
            

            

                
            

            

                
    let v4 = constructor_icmp(ctx, arg0, &IntCC::NotEqual, arg1, arg2);

            

        

            

                207
            

            

                
            

            

                
    // Rule at src/prelude_opt.isle line 21.

            

        

            

                208
            

            

                
            

            

                
    return v4;

            

        

            

                209
            

            

                
            

            

                
}

            

        

            

                210
            

            

                
            

            

                

            

        

            

                211
            

            

                
            

            

                
// Generated as internal constructor for term ult.

            

        

            

                212
            

            

                
            

            

                
pub fn constructor_ult<C: Context>(ctx: &mut C, arg0: Type, arg1: Value, arg2: Value) -> Value {

            

        

            

                213
            

            

                
            

            

                
    let v4 = constructor_icmp(ctx, arg0, &IntCC::UnsignedLessThan, arg1, arg2);

            

        

            

                214
            

            

                
            

            

                
    // Rule at src/prelude_opt.isle line 22.

            

        

            

                215
            

            

                
            

            

                
    return v4;

            

        

            

                216
            

            

                
            

            

                
}

            

        

            

                217
            

            

                
            

            

                

            

        

            

                218
            

            

                
            

            

                
// Generated as internal constructor for term ule.

            

        

            

                219
            

            

                
            

            

                
pub fn constructor_ule<C: Context>(ctx: &mut C, arg0: Type, arg1: Value, arg2: Value) -> Value {

            

        

            

                220
            

            

                
            

            

                
    let v4 = constructor_icmp(ctx, arg0, &IntCC::UnsignedLessThanOrEqual, arg1, arg2);

            

        

            

                221
            

            

                
            

            

                
    // Rule at src/prelude_opt.isle line 23.

            

        

            

                222
            

            

                
            

            

                
    return v4;

            

        

            

                223
            

            

                
            

            

                
}

            

        

            

                224
            

            

                
            

            

                

            

        

            

                225
            

            

                
            

            

                
// Generated as internal constructor for term ugt.

            

        

            

                226
            

            

                
            

            

                
pub fn constructor_ugt<C: Context>(ctx: &mut C, arg0: Type, arg1: Value, arg2: Value) -> Value {

            

        

            

                227
            

            

                
            

            

                
    let v4 = constructor_icmp(ctx, arg0, &IntCC::UnsignedGreaterThan, arg1, arg2);

            

        

            

                228
            

            

                
            

            

                
    // Rule at src/prelude_opt.isle line 24.

            

        

            

                229
            

            

                
            

            

                
    return v4;

            

        

            

                230
            

            

                
            

            

                
}

            

        

            

                231
            

            

                
            

            

                

            

        

            

                232
            

            

                
            

            

                
// Generated as internal constructor for term uge.

            

        

            

                233
            

            

                
            

            

                
pub fn constructor_uge<C: Context>(ctx: &mut C, arg0: Type, arg1: Value, arg2: Value) -> Value {

            

        

            

                234
            

            

                
            

            

                
    let v4 = constructor_icmp(ctx, arg0, &IntCC::UnsignedGreaterThanOrEqual, arg1, arg2);

            

        

            

                235
            

            

                
            

            

                
    // Rule at src/prelude_opt.isle line 25.

            

        

            

                236
            

            

                
            

            

                
    return v4;

            

        

            

                237
            

            

                
            

            

                
}

            

        

            

                238
            

            

                
            

            

                

            

        

            

                239
            

            

                
            

            

                
// Generated as internal constructor for term slt.

            

        

            

                240
            

            

                
            

            

                
pub fn constructor_slt<C: Context>(ctx: &mut C, arg0: Type, arg1: Value, arg2: Value) -> Value {

            

        

            

                241
            

            

                
            

            

                
    let v4 = constructor_icmp(ctx, arg0, &IntCC::SignedLessThan, arg1, arg2);

            

        

            

                242
            

            

                
            

            

                
    // Rule at src/prelude_opt.isle line 26.

            

        

            

                243
            

            

                
            

            

                
    return v4;

            

        

            

                244
            

            

                
            

            

                
}

            

        

            

                245
            

            

                
            

            

                

            

        

            

                246
            

            

                
            

            

                
// Generated as internal constructor for term sle.

            

        

            

                247
            

            

                
            

            

                
pub fn constructor_sle<C: Context>(ctx: &mut C, arg0: Type, arg1: Value, arg2: Value) -> Value {

            

        

            

                248
            

            

                
            

            

                
    let v4 = constructor_icmp(ctx, arg0, &IntCC::SignedLessThanOrEqual, arg1, arg2);

            

        

            

                249
            

            

                
            

            

                
    // Rule at src/prelude_opt.isle line 27.

            

        

            

                250
            

            

                
            

            

                
    return v4;

            

        

            

                251
            

            

                
            

            

                
}

            

        

            

                252
            

            

                
            

            

                

            

        

            

                253
            

            

                
            

            

                
// Generated as internal constructor for term sgt.

            

        

            

                254
            

            

                
            

            

                
pub fn constructor_sgt<C: Context>(ctx: &mut C, arg0: Type, arg1: Value, arg2: Value) -> Value {

            

        

            

                255
            

            

                
            

            

                
    let v4 = constructor_icmp(ctx, arg0, &IntCC::SignedGreaterThan, arg1, arg2);

            

        

            

                256
            

            

                
            

            

                
    // Rule at src/prelude_opt.isle line 28.

            

        

            

                257
            

            

                
            

            

                
    return v4;

            

        

            

                258
            

            

                
            

            

                
}

            

        

            

                259
            

            

                
            

            

                

            

        

            

                260
            

            

                
            

            

                
// Generated as internal constructor for term sge.

            

        

            

                261
            

            

                
            

            

                
pub fn constructor_sge<C: Context>(ctx: &mut C, arg0: Type, arg1: Value, arg2: Value) -> Value {

            

        

            

                262
            

            

                
            

            

                
    let v4 = constructor_icmp(ctx, arg0, &IntCC::SignedGreaterThanOrEqual, arg1, arg2);

            

        

            

                263
            

            

                
            

            

                
    // Rule at src/prelude_opt.isle line 29.

            

        

            

                264
            

            

                
            

            

                
    return v4;

            

        

            

                265
            

            

                
            

            

                
}

            

        

            

                266
            

            

                
            

            

                

            

        

            

                267
            

            

                
            

            

                
// Generated as internal constructor for term simplify.

            

        

            

                268
            

            

                
            

            

                
pub fn constructor_simplify<C: Context>(

            

        

            

                269
            

            

                
            

            

                
    ctx: &mut C,

            

        

            

                270
            

            

                
            

            

                
    arg0: Value,

            

        

            

                271
            

            

                
            

            

                
) -> impl ContextIter<Context = C, Output = Value> {

            

        

            

                272
            

            

                
            

            

                
    let mut returns = ConstructorVec::new();

            

        

            

                273
            

            

                
            

            

                
    let v1 = C::inst_data_etor(ctx, arg0);

            

        

            

                274
            

            

                
            

            

                
    let mut v1 = v1;

            

        

            

                275
            

            

                
            

            

                
    while let Some(v2) = v1.next(ctx) {

            

        

            

                276
            

            

                
            

            

                
        match &v2.1 {

            

        

            

                277
            

            

                
            

            

                
            &InstructionData::Binary {

            

        

            

                278
            

            

                
            

            

                
                opcode: ref v5,

            

        

            

                279
            

            

                
            

            

                
                args: ref v6,

            

        

            

                280
            

            

                
            

            

                
            } => {

            

        

            

                281
            

            

                
            

            

                
                match v5 {

            

        

            

                282
            

            

                
            

            

                
                    &Opcode::Smin => {

            

        

            

                283
            

            

                
            

            

                
                        let v7 = C::unpack_value_array_2(ctx, v6);

            

        

            

                284
            

            

                
            

            

                
                        let v10 = C::inst_data_etor(ctx, v7.1);

            

        

            

                285
            

            

                
            

            

                
                        let mut v10 = v10;

            

        

            

                286
            

            

                
            

            

                
                        while let Some(v11) = v10.next(ctx) {

            

        

            

                287
            

            

                
            

            

                
                            if let &InstructionData::Unary {

            

        

            

                288
            

            

                
            

            

                
                                opcode: ref v38,

            

        

            

                289
            

            

                
            

            

                
                                arg: v39,

            

        

            

                290
            

            

                
            

            

                
                            } = &v11.1

            

        

            

                291
            

            

                
            

            

                
                            {

            

        

            

                292
            

            

                
            

            

                
                                if let &Opcode::Splat = v38 {

            

        

            

                293
            

            

                
            

            

                
                                    if v2.0 == v11.0 {

            

        

            

                294
            

            

                
            

            

                
                                        let v18 = C::inst_data_etor(ctx, v7.0);

            

        

            

                295
            

            

                
            

            

                
                                        let mut v18 = v18;

            

        

            

                296
            

            

                
            

            

                
                                        while let Some(v19) = v18.next(ctx) {

            

        

            

                297
            

            

                
            

            

                
                                            if let &InstructionData::Unary {

            

        

            

                298
            

            

                
            

            

                
                                                opcode: ref v36,

            

        

            

                299
            

            

                
            

            

                
                                                arg: v37,

            

        

            

                300
            

            

                
            

            

                
                                            } = &v19.1

            

        

            

                301
            

            

                
            

            

                
                                            {

            

        

            

                302
            

            

                
            

            

                
                                                if let &Opcode::Splat = v36 {

            

        

            

                303
            

            

                
            

            

                
                                                    if v2.0 == v19.0 {

            

        

            

                304
            

            

                
            

            

                
                                                        let v481 = C::lane_type(ctx, v2.0);

            

        

            

                305
            

            

                
            

            

                
                                                        let v512 =

            

        

            

                306
            

            

                
            

            

                
                                                            constructor_smin(ctx, v481, v37, v39);

            

        

            

                307
            

            

                
            

            

                
                                                        let v513 =

            

        

            

                308
            

            

                
            

            

                
                                                            constructor_splat(ctx, v2.0, v512);

            

        

            

                309
            

            

                
            

            

                
                                                        // Rule at src/opts/vector.isle line 54.

            

        

            

                310
            

            

                
            

            

                
                                                        returns.push(v513);

            

        

            

                311
            

            

                
            

            

                
                                                    }

            

        

            

                312
            

            

                
            

            

                
                                                }

            

        

            

                313
            

            

                
            

            

                
                                            }

            

        

            

                314
            

            

                
            

            

                
                                        }

            

        

            

                315
            

            

                
            

            

                
                                    }

            

        

            

                316
            

            

                
            

            

                
                                }

            

        

            

                317
            

            

                
            

            

                
                            }

            

        

            

                318
            

            

                
            

            

                
                        }

            

        

            

                319
            

            

                
            

            

                
                    }

            

        

            

                320
            

            

                
            

            

                
                    &Opcode::Umin => {

            

        

            

                321
            

            

                
            

            

                
                        let v7 = C::unpack_value_array_2(ctx, v6);

            

        

            

                322
            

            

                
            

            

                
                        let v10 = C::inst_data_etor(ctx, v7.1);

            

        

            

                323
            

            

                
            

            

                
                        let mut v10 = v10;

            

        

            

                324
            

            

                
            

            

                
                        while let Some(v11) = v10.next(ctx) {

            

        

            

                325
            

            

                
            

            

                
                            if let &InstructionData::Unary {

            

        

            

                326
            

            

                
            

            

                
                                opcode: ref v38,

            

        

            

                327
            

            

                
            

            

                
                                arg: v39,

            

        

            

                328
            

            

                
            

            

                
                            } = &v11.1

            

        

            

                329
            

            

                
            

            

                
                            {

            

        

            

                330
            

            

                
            

            

                
                                if let &Opcode::Splat = v38 {

            

        

            

                331
            

            

                
            

            

                
                                    if v2.0 == v11.0 {

            

        

            

                332
            

            

                
            

            

                
                                        let v18 = C::inst_data_etor(ctx, v7.0);

            

        

            

                333
            

            

                
            

            

                
                                        let mut v18 = v18;

            

        

            

                334
            

            

                
            

            

                
                                        while let Some(v19) = v18.next(ctx) {

            

        

            

                335
            

            

                
            

            

                
                                            if let &InstructionData::Unary {

            

        

            

                336
            

            

                
            

            

                
                                                opcode: ref v36,

            

        

            

                337
            

            

                
            

            

                
                                                arg: v37,

            

        

            

                338
            

            

                
            

            

                
                                            } = &v19.1

            

        

            

                339
            

            

                
            

            

                
                                            {

            

        

            

                340
            

            

                
            

            

                
                                                if let &Opcode::Splat = v36 {

            

        

            

                341
            

            

                
            

            

                
                                                    if v2.0 == v19.0 {

            

        

            

                342
            

            

                
            

            

                
                                                        let v481 = C::lane_type(ctx, v2.0);

            

        

            

                343
            

            

                
            

            

                
                                                        let v514 =

            

        

            

                344
            

            

                
            

            

                
                                                            constructor_umin(ctx, v481, v37, v39);

            

        

            

                345
            

            

                
            

            

                
                                                        let v515 =

            

        

            

                346
            

            

                
            

            

                
                                                            constructor_splat(ctx, v2.0, v514);

            

        

            

                347
            

            

                
            

            

                
                                                        // Rule at src/opts/vector.isle line 57.

            

        

            

                348
            

            

                
            

            

                
                                                        returns.push(v515);

            

        

            

                349
            

            

                
            

            

                
                                                    }

            

        

            

                350
            

            

                
            

            

                
                                                }

            

        

            

                351
            

            

                
            

            

                
                                            }

            

        

            

                352
            

            

                
            

            

                
                                        }

            

        

            

                353
            

            

                
            

            

                
                                    }

            

        

            

                354
            

            

                
            

            

                
                                }

            

        

            

                355
            

            

                
            

            

                
                            }

            

        

            

                356
            

            

                
            

            

                
                        }

            

        

            

                357
            

            

                
            

            

                
                    }

            

        

            

                358
            

            

                
            

            

                
                    &Opcode::Smax => {

            

        

            

                359
            

            

                
            

            

                
                        let v7 = C::unpack_value_array_2(ctx, v6);

            

        

            

                360
            

            

                
            

            

                
                        let v10 = C::inst_data_etor(ctx, v7.1);

            

        

            

                361
            

            

                
            

            

                
                        let mut v10 = v10;

            

        

            

                362
            

            

                
            

            

                
                        while let Some(v11) = v10.next(ctx) {

            

        

            

                363
            

            

                
            

            

                
                            if let &InstructionData::Unary {

            

        

            

                364
            

            

                
            

            

                
                                opcode: ref v38,

            

        

            

                365
            

            

                
            

            

                
                                arg: v39,

            

        

            

                366
            

            

                
            

            

                
                            } = &v11.1

            

        

            

                367
            

            

                
            

            

                
                            {

            

        

            

                368
            

            

                
            

            

                
                                if let &Opcode::Splat = v38 {

            

        

            

                369
            

            

                
            

            

                
                                    if v2.0 == v11.0 {

            

        

            

                370
            

            

                
            

            

                
                                        let v18 = C::inst_data_etor(ctx, v7.0);

            

        

            

                371
            

            

                
            

            

                
                                        let mut v18 = v18;

            

        

            

                372
            

            

                
            

            

                
                                        while let Some(v19) = v18.next(ctx) {

            

        

            

                373
            

            

                
            

            

                
                                            if let &InstructionData::Unary {

            

        

            

                374
            

            

                
            

            

                
                                                opcode: ref v36,

            

        

            

                375
            

            

                
            

            

                
                                                arg: v37,

            

        

            

                376
            

            

                
            

            

                
                                            } = &v19.1

            

        

            

                377
            

            

                
            

            

                
                                            {

            

        

            

                378
            

            

                
            

            

                
                                                if let &Opcode::Splat = v36 {

            

        

            

                379
            

            

                
            

            

                
                                                    if v2.0 == v19.0 {

            

        

            

                380
            

            

                
            

            

                
                                                        let v481 = C::lane_type(ctx, v2.0);

            

        

            

                381
            

            

                
            

            

                
                                                        let v516 =

            

        

            

                382
            

            

                
            

            

                
                                                            constructor_smax(ctx, v481, v37, v39);

            

        

            

                383
            

            

                
            

            

                
                                                        let v517 =

            

        

            

                384
            

            

                
            

            

                
                                                            constructor_splat(ctx, v2.0, v516);

            

        

            

                385
            

            

                
            

            

                
                                                        // Rule at src/opts/vector.isle line 60.

            

        

            

                386
            

            

                
            

            

                
                                                        returns.push(v517);

            

        

            

                387
            

            

                
            

            

                
                                                    }

            

        

            

                388
            

            

                
            

            

                
                                                }

            

        

            

                389
            

            

                
            

            

                
                                            }

            

        

            

                390
            

            

                
            

            

                
                                        }

            

        

            

                391
            

            

                
            

            

                
                                    }

            

        

            

                392
            

            

                
            

            

                
                                }

            

        

            

                393
            

            

                
            

            

                
                            }

            

        

            

                394
            

            

                
            

            

                
                        }

            

        

            

                395
            

            

                
            

            

                
                    }

            

        

            

                396
            

            

                
            

            

                
                    &Opcode::Umax => {

            

        

            

                397
            

            

                
            

            

                
                        let v7 = C::unpack_value_array_2(ctx, v6);

            

        

            

                398
            

            

                
            

            

                
                        let v10 = C::inst_data_etor(ctx, v7.1);

            

        

            

                399
            

            

                
            

            

                
                        let mut v10 = v10;

            

        

            

                400
            

            

                
            

            

                
                        while let Some(v11) = v10.next(ctx) {

            

        

            

                401
            

            

                
            

            

                
                            if let &InstructionData::Unary {

            

        

            

                402
            

            

                
            

            

                
                                opcode: ref v38,

            

        

            

                403
            

            

                
            

            

                
                                arg: v39,

            

        

            

                404
            

            

                
            

            

                
                            } = &v11.1

            

        

            

                405
            

            

                
            

            

                
                            {

            

        

            

                406
            

            

                
            

            

                
                                if let &Opcode::Splat = v38 {

            

        

            

                407
            

            

                
            

            

                
                                    if v2.0 == v11.0 {

            

        

            

                408
            

            

                
            

            

                
                                        let v18 = C::inst_data_etor(ctx, v7.0);

            

        

            

                409
            

            

                
            

            

                
                                        let mut v18 = v18;

            

        

            

                410
            

            

                
            

            

                
                                        while let Some(v19) = v18.next(ctx) {

            

        

            

                411
            

            

                
            

            

                
                                            if let &InstructionData::Unary {

            

        

            

                412
            

            

                
            

            

                
                                                opcode: ref v36,

            

        

            

                413
            

            

                
            

            

                
                                                arg: v37,

            

        

            

                414
            

            

                
            

            

                
                                            } = &v19.1

            

        

            

                415
            

            

                
            

            

                
                                            {

            

        

            

                416
            

            

                
            

            

                
                                                if let &Opcode::Splat = v36 {

            

        

            

                417
            

            

                
            

            

                
                                                    if v2.0 == v19.0 {

            

        

            

                418
            

            

                
            

            

                
                                                        let v481 = C::lane_type(ctx, v2.0);

            

        

            

                419
            

            

                
            

            

                
                                                        let v518 =

            

        

            

                420
            

            

                
            

            

                
                                                            constructor_umax(ctx, v481, v37, v39);

            

        

            

                421
            

            

                
            

            

                
                                                        let v519 =

            

        

            

                422
            

            

                
            

            

                
                                                            constructor_splat(ctx, v2.0, v518);

            

        

            

                423
            

            

                
            

            

                
                                                        // Rule at src/opts/vector.isle line 63.

            

        

            

                424
            

            

                
            

            

                
                                                        returns.push(v519);

            

        

            

                425
            

            

                
            

            

                
                                                    }

            

        

            

                426
            

            

                
            

            

                
                                                }

            

        

            

                427
            

            

                
            

            

                
                                            }

            

        

            

                428
            

            

                
            

            

                
                                        }

            

        

            

                429
            

            

                
            

            

                
                                    }

            

        

            

                430
            

            

                
            

            

                
                                }

            

        

            

                431
            

            

                
            

            

                
                            }

            

        

            

                432
            

            

                
            

            

                
                        }

            

        

            

                433
            

            

                
            

            

                
                    }

            

        

            

                434
            

            

                
            

            

                
                    &Opcode::Iadd => {

            

        

            

                435
            

            

                
            

            

                
                        let v7 = C::unpack_value_array_2(ctx, v6);

            

        

            

                436
            

            

                
            

            

                
                        let v18 = C::inst_data_etor(ctx, v7.0);

            

        

            

                437
            

            

                
            

            

                
                        let mut v18 = v18;

            

        

            

                438
            

            

                
            

            

                
                        while let Some(v19) = v18.next(ctx) {

            

        

            

                439
            

            

                
            

            

                
                            match &v19.1 {

            

        

            

                440
            

            

                
            

            

                
                                &InstructionData::Binary {

            

        

            

                441
            

            

                
            

            

                
                                    opcode: ref v123,

            

        

            

                442
            

            

                
            

            

                
                                    args: ref v124,

            

        

            

                443
            

            

                
            

            

                
                                } => {

            

        

            

                444
            

            

                
            

            

                
                                    match v123 {

            

        

            

                445
            

            

                
            

            

                
                                        &Opcode::Iadd => {

            

        

            

                446
            

            

                
            

            

                
                                            if v2.0 == v19.0 {

            

        

            

                447
            

            

                
            

            

                
                                                let v10 = C::inst_data_etor(ctx, v7.1);

            

        

            

                448
            

            

                
            

            

                
                                                let mut v10 = v10;

            

        

            

                449
            

            

                
            

            

                
                                                while let Some(v11) = v10.next(ctx) {

            

        

            

                450
            

            

                
            

            

                
                                                    if let &InstructionData::UnaryImm {

            

        

            

                451
            

            

                
            

            

                
                                                        opcode: ref v14,

            

        

            

                452
            

            

                
            

            

                
                                                        imm: v15,

            

        

            

                453
            

            

                
            

            

                
                                                    } = &v11.1

            

        

            

                454
            

            

                
            

            

                
                                                    {

            

        

            

                455
            

            

                
            

            

                
                                                        if let &Opcode::Iconst = v14 {

            

        

            

                456
            

            

                
            

            

                
                                                            if v2.0 == v11.0 {

            

        

            

                457
            

            

                
            

            

                
                                                                let v125 = C::unpack_value_array_2(

            

        

            

                458
            

            

                
            

            

                
                                                                    ctx, v124,

            

        

            

                459
            

            

                
            

            

                
                                                                );

            

        

            

                460
            

            

                
            

            

                
                                                                let v135 =

            

        

            

                461
            

            

                
            

            

                
                                                                    C::inst_data_etor(ctx, v125.1);

            

        

            

                462
            

            

                
            

            

                
                                                                let mut v135 = v135;

            

        

            

                463
            

            

                
            

            

                
                                                                while let Some(v136) =

            

        

            

                464
            

            

                
            

            

                
                                                                    v135.next(ctx)

            

        

            

                465
            

            

                
            

            

                
                                                                {

            

        

            

                466
            

            

                
            

            

                
                                                                    if let &InstructionData::UnaryImm {

            

        

            

                467
            

            

                
            

            

                
                                                                        opcode: ref v139,

            

        

            

                468
            

            

                
            

            

                
                                                                        imm: v140,

            

        

            

                469
            

            

                
            

            

                
                                                                    } = &v136.1 {

            

        

            

                470
            

            

                
            

            

                
                                                                        if let &Opcode::Iconst = v139 {

            

        

            

                471
            

            

                
            

            

                
                                                                            if v2.0 == v136.0 {

            

        

            

                472
            

            

                
            

            

                
                                                                                let v270 = constructor_iadd(ctx, v2.0, v125.1, v7.1);

            

        

            

                473
            

            

                
            

            

                
                                                                                let v271 = constructor_iadd(ctx, v2.0, v125.0, v270);

            

        

            

                474
            

            

                
            

            

                
                                                                                // Rule at src/opts/cprop.isle line 125.

            

        

            

                475
            

            

                
            

            

                
                                                                                returns.push(v271);

            

        

            

                476
            

            

                
            

            

                
                                                                            }

            

        

            

                477
            

            

                
            

            

                
                                                                        }

            

        

            

                478
            

            

                
            

            

                
                                                                    }

            

        

            

                479
            

            

                
            

            

                
                                                                }

            

        

            

                480
            

            

                
            

            

                
                                                            }

            

        

            

                481
            

            

                
            

            

                
                                                        }

            

        

            

                482
            

            

                
            

            

                
                                                    }

            

        

            

                483
            

            

                
            

            

                
                                                }

            

        

            

                484
            

            

                
            

            

                
                                            }

            

        

            

                485
            

            

                
            

            

                
                                        }

            

        

            

                486
            

            

                
            

            

                
                                        &Opcode::Isub => {

            

        

            

                487
            

            

                
            

            

                
                                            if v2.0 == v19.0 {

            

        

            

                488
            

            

                
            

            

                
                                                let v10 = C::inst_data_etor(ctx, v7.1);

            

        

            

                489
            

            

                
            

            

                
                                                let mut v10 = v10;

            

        

            

                490
            

            

                
            

            

                
                                                while let Some(v11) = v10.next(ctx) {

            

        

            

                491
            

            

                
            

            

                
                                                    if let &InstructionData::UnaryImm {

            

        

            

                492
            

            

                
            

            

                
                                                        opcode: ref v14,

            

        

            

                493
            

            

                
            

            

                
                                                        imm: v15,

            

        

            

                494
            

            

                
            

            

                
                                                    } = &v11.1

            

        

            

                495
            

            

                
            

            

                
                                                    {

            

        

            

                496
            

            

                
            

            

                
                                                        if let &Opcode::Iconst = v14 {

            

        

            

                497
            

            

                
            

            

                
                                                            if v2.0 == v11.0 {

            

        

            

                498
            

            

                
            

            

                
                                                                let v125 = C::unpack_value_array_2(

            

        

            

                499
            

            

                
            

            

                
                                                                    ctx, v124,

            

        

            

                500
            

            

                
            

            

                
                                                                );

            

        

            

                501
            

            

                
            

            

                
                                                                let v135 =

            

        

            

                502
            

            

                
            

            

                
                                                                    C::inst_data_etor(ctx, v125.1);

            

        

            

                503
            

            

                
            

            

                
                                                                let mut v135 = v135;

            

        

            

                504
            

            

                
            

            

                
                                                                while let Some(v136) =

            

        

            

                505
            

            

                
            

            

                
                                                                    v135.next(ctx)

            

        

            

                506
            

            

                
            

            

                
                                                                {

            

        

            

                507
            

            

                
            

            

                
                                                                    if let &InstructionData::UnaryImm {

            

        

            

                508
            

            

                
            

            

                
                                                                        opcode: ref v139,

            

        

            

                509
            

            

                
            

            

                
                                                                        imm: v140,

            

        

            

                510
            

            

                
            

            

                
                                                                    } = &v136.1 {

            

        

            

                511
            

            

                
            

            

                
                                                                        if let &Opcode::Iconst = v139 {

            

        

            

                512
            

            

                
            

            

                
                                                                            if v2.0 == v136.0 {

            

        

            

                513
            

            

                
            

            

                
                                                                                let v16 = C::u64_from_imm64(ctx, v15);

            

        

            

                514
            

            

                
            

            

                
                                                                                let v141 = C::u64_from_imm64(ctx, v140);

            

        

            

                515
            

            

                
            

            

                
                                                                                let v283 = C::u64_sub(ctx, v16, v141);

            

        

            

                516
            

            

                
            

            

                
                                                                                let v284 = C::imm64_masked(ctx, v2.0, v283);

            

        

            

                517
            

            

                
            

            

                
                                                                                let v285 = constructor_iconst(ctx, v2.0, v284);

            

        

            

                518
            

            

                
            

            

                
                                                                                let v287 = constructor_iadd(ctx, v2.0, v125.0, v285);

            

        

            

                519
            

            

                
            

            

                
                                                                                // Rule at src/opts/cprop.isle line 147.

            

        

            

                520
            

            

                
            

            

                
                                                                                returns.push(v287);

            

        

            

                521
            

            

                
            

            

                
                                                                            }

            

        

            

                522
            

            

                
            

            

                
                                                                        }

            

        

            

                523
            

            

                
            

            

                
                                                                    }

            

        

            

                524
            

            

                
            

            

                
                                                                }

            

        

            

                525
            

            

                
            

            

                
                                                                let v156 =

            

        

            

                526
            

            

                
            

            

                
                                                                    C::inst_data_etor(ctx, v125.0);

            

        

            

                527
            

            

                
            

            

                
                                                                let mut v156 = v156;

            

        

            

                528
            

            

                
            

            

                
                                                                while let Some(v157) =

            

        

            

                529
            

            

                
            

            

                
                                                                    v156.next(ctx)

            

        

            

                530
            

            

                
            

            

                
                                                                {

            

        

            

                531
            

            

                
            

            

                
                                                                    if let &InstructionData::UnaryImm {

            

        

            

                532
            

            

                
            

            

                
                                                                        opcode: ref v276,

            

        

            

                533
            

            

                
            

            

                
                                                                        imm: v277,

            

        

            

                534
            

            

                
            

            

                
                                                                    } = &v157.1 {

            

        

            

                535
            

            

                
            

            

                
                                                                        if let &Opcode::Iconst = v276 {

            

        

            

                536
            

            

                
            

            

                
                                                                            if v2.0 == v157.0 {

            

        

            

                537
            

            

                
            

            

                
                                                                                let v278 = C::u64_from_imm64(ctx, v277);

            

        

            

                538
            

            

                
            

            

                
                                                                                let v16 = C::u64_from_imm64(ctx, v15);

            

        

            

                539
            

            

                
            

            

                
                                                                                let v288 = C::u64_add(ctx, v278, v16);

            

        

            

                540
            

            

                
            

            

                
                                                                                let v289 = C::imm64_masked(ctx, v2.0, v288);

            

        

            

                541
            

            

                
            

            

                
                                                                                let v290 = constructor_iconst(ctx, v2.0, v289);

            

        

            

                542
            

            

                
            

            

                
                                                                                let v291 = constructor_isub(ctx, v2.0, v290, v125.1);

            

        

            

                543
            

            

                
            

            

                
                                                                                // Rule at src/opts/cprop.isle line 151.

            

        

            

                544
            

            

                
            

            

                
                                                                                returns.push(v291);

            

        

            

                545
            

            

                
            

            

                
                                                                            }

            

        

            

                546
            

            

                
            

            

                
                                                                        }

            

        

            

                547
            

            

                
            

            

                
                                                                    }

            

        

            

                548
            

            

                
            

            

                
                                                                }

            

        

            

                549
            

            

                
            

            

                
                                                            }

            

        

            

                550
            

            

                
            

            

                
                                                        }

            

        

            

                551
            

            

                
            

            

                
                                                    }

            

        

            

                552
            

            

                
            

            

                
                                                }

            

        

            

                553
            

            

                
            

            

                
                                            }

            

        

            

                554
            

            

                
            

            

                
                                        }

            

        

            

                555
            

            

                
            

            

                
                                        _ => {}

            

        

            

                556
            

            

                
            

            

                
                                    }

            

        

            

                557
            

            

                
            

            

                
                                }

            

        

            

                558
            

            

                
            

            

                
                                &InstructionData::Unary {

            

        

            

                559
            

            

                
            

            

                
                                    opcode: ref v36,

            

        

            

                560
            

            

                
            

            

                
                                    arg: v37,

            

        

            

                561
            

            

                
            

            

                
                                } => {

            

        

            

                562
            

            

                
            

            

                
                                    match v36 {

            

        

            

                563
            

            

                
            

            

                
                                        &Opcode::Splat => {

            

        

            

                564
            

            

                
            

            

                
                                            if v2.0 == v19.0 {

            

        

            

                565
            

            

                
            

            

                
                                                let v10 = C::inst_data_etor(ctx, v7.1);

            

        

            

                566
            

            

                
            

            

                
                                                let mut v10 = v10;

            

        

            

                567
            

            

                
            

            

                
                                                while let Some(v11) = v10.next(ctx) {

            

        

            

                568
            

            

                
            

            

                
                                                    if let &InstructionData::Unary {

            

        

            

                569
            

            

                
            

            

                
                                                        opcode: ref v38,

            

        

            

                570
            

            

                
            

            

                
                                                        arg: v39,

            

        

            

                571
            

            

                
            

            

                
                                                    } = &v11.1

            

        

            

                572
            

            

                
            

            

                
                                                    {

            

        

            

                573
            

            

                
            

            

                
                                                        if let &Opcode::Splat = v38 {

            

        

            

                574
            

            

                
            

            

                
                                                            if v2.0 == v11.0 {

            

        

            

                575
            

            

                
            

            

                
                                                                let v481 = C::lane_type(ctx, v2.0);

            

        

            

                576
            

            

                
            

            

                
                                                                let v496 = constructor_iadd(

            

        

            

                577
            

            

                
            

            

                
                                                                    ctx, v481, v37, v39,

            

        

            

                578
            

            

                
            

            

                
                                                                );

            

        

            

                579
            

            

                
            

            

                
                                                                let v497 = constructor_splat(

            

        

            

                580
            

            

                
            

            

                
                                                                    ctx, v2.0, v496,

            

        

            

                581
            

            

                
            

            

                
                                                                );

            

        

            

                582
            

            

                
            

            

                
                                                                // Rule at src/opts/vector.isle line 30.

            

        

            

                583
            

            

                
            

            

                
                                                                returns.push(v497);

            

        

            

                584
            

            

                
            

            

                
                                                            }

            

        

            

                585
            

            

                
            

            

                
                                                        }

            

        

            

                586
            

            

                
            

            

                
                                                    }

            

        

            

                587
            

            

                
            

            

                
                                                }

            

        

            

                588
            

            

                
            

            

                
                                            }

            

        

            

                589
            

            

                
            

            

                
                                        }

            

        

            

                590
            

            

                
            

            

                
                                        &Opcode::Bnot => {

            

        

            

                591
            

            

                
            

            

                
                                            if v2.0 == v19.0 {

            

        

            

                592
            

            

                
            

            

                
                                                let v10 = C::inst_data_etor(ctx, v7.1);

            

        

            

                593
            

            

                
            

            

                
                                                let mut v10 = v10;

            

        

            

                594
            

            

                
            

            

                
                                                while let Some(v11) = v10.next(ctx) {

            

        

            

                595
            

            

                
            

            

                
                                                    if let &InstructionData::UnaryImm {

            

        

            

                596
            

            

                
            

            

                
                                                        opcode: ref v14,

            

        

            

                597
            

            

                
            

            

                
                                                        imm: v15,

            

        

            

                598
            

            

                
            

            

                
                                                    } = &v11.1

            

        

            

                599
            

            

                
            

            

                
                                                    {

            

        

            

                600
            

            

                
            

            

                
                                                        if let &Opcode::Iconst = v14 {

            

        

            

                601
            

            

                
            

            

                
                                                            let v16 = C::u64_from_imm64(ctx, v15);

            

        

            

                602
            

            

                
            

            

                
                                                            if v16 == 0x1 {

            

        

            

                603
            

            

                
            

            

                
                                                                if v2.0 == v11.0 {

            

        

            

                604
            

            

                
            

            

                
                                                                    let v55 = constructor_ineg(

            

        

            

                605
            

            

                
            

            

                
                                                                        ctx, v2.0, v37,

            

        

            

                606
            

            

                
            

            

                
                                                                    );

            

        

            

                607
            

            

                
            

            

                
                                                                    // Rule at src/opts/arithmetic.isle line 71.

            

        

            

                608
            

            

                
            

            

                
                                                                    returns.push(v55);

            

        

            

                609
            

            

                
            

            

                
                                                                }

            

        

            

                610
            

            

                
            

            

                
                                                            }

            

        

            

                611
            

            

                
            

            

                
                                                        }

            

        

            

                612
            

            

                
            

            

                
                                                    }

            

        

            

                613
            

            

                
            

            

                
                                                }

            

        

            

                614
            

            

                
            

            

                
                                            }

            

        

            

                615
            

            

                
            

            

                
                                        }

            

        

            

                616
            

            

                
            

            

                
                                        _ => {}

            

        

            

                617
            

            

                
            

            

                
                                    }

            

        

            

                618
            

            

                
            

            

                
                                }

            

        

            

                619
            

            

                
            

            

                
                                &InstructionData::UnaryImm {

            

        

            

                620
            

            

                
            

            

                
                                    opcode: ref v22,

            

        

            

                621
            

            

                
            

            

                
                                    imm: v23,

            

        

            

                622
            

            

                
            

            

                
                                } => {

            

        

            

                623
            

            

                
            

            

                
                                    if let &Opcode::Iconst = v22 {

            

        

            

                624
            

            

                
            

            

                
                                        if v2.0 == v19.0 {

            

        

            

                625
            

            

                
            

            

                
                                            let v24 = C::u64_from_imm64(ctx, v23);

            

        

            

                626
            

            

                
            

            

                
                                            match v24 {

            

        

            

                627
            

            

                
            

            

                
                                                0x0 => {

            

        

            

                628
            

            

                
            

            

                
                                                    let v25 = C::subsume(ctx, v7.1);

            

        

            

                629
            

            

                
            

            

                
                                                    // Rule at src/opts/arithmetic.isle line 9.

            

        

            

                630
            

            

                
            

            

                
                                                    returns.push(v25);

            

        

            

                631
            

            

                
            

            

                
                                                }

            

        

            

                632
            

            

                
            

            

                
                                                0x1 => {

            

        

            

                633
            

            

                
            

            

                
                                                    let v10 = C::inst_data_etor(ctx, v7.1);

            

        

            

                634
            

            

                
            

            

                
                                                    let mut v10 = v10;

            

        

            

                635
            

            

                
            

            

                
                                                    while let Some(v11) = v10.next(ctx) {

            

        

            

                636
            

            

                
            

            

                
                                                        if let &InstructionData::Unary {

            

        

            

                637
            

            

                
            

            

                
                                                            opcode: ref v38,

            

        

            

                638
            

            

                
            

            

                
                                                            arg: v39,

            

        

            

                639
            

            

                
            

            

                
                                                        } = &v11.1

            

        

            

                640
            

            

                
            

            

                
                                                        {

            

        

            

                641
            

            

                
            

            

                
                                                            if let &Opcode::Bnot = v38 {

            

        

            

                642
            

            

                
            

            

                
                                                                if v2.0 == v11.0 {

            

        

            

                643
            

            

                
            

            

                
                                                                    let v56 = constructor_ineg(

            

        

            

                644
            

            

                
            

            

                
                                                                        ctx, v2.0, v39,

            

        

            

                645
            

            

                
            

            

                
                                                                    );

            

        

            

                646
            

            

                
            

            

                
                                                                    // Rule at src/opts/arithmetic.isle line 73.

            

        

            

                647
            

            

                
            

            

                
                                                                    returns.push(v56);

            

        

            

                648
            

            

                
            

            

                
                                                                }

            

        

            

                649
            

            

                
            

            

                
                                                            }

            

        

            

                650
            

            

                
            

            

                
                                                        }

            

        

            

                651
            

            

                
            

            

                
                                                    }

            

        

            

                652
            

            

                
            

            

                
                                                }

            

        

            

                653
            

            

                
            

            

                
                                                _ => {}

            

        

            

                654
            

            

                
            

            

                
                                            }

            

        

            

                655
            

            

                
            

            

                
                                            let v261 = constructor_iadd(ctx, v2.0, v7.1, v7.0);

            

        

            

                656
            

            

                
            

            

                
                                            // Rule at src/opts/cprop.isle line 94.

            

        

            

                657
            

            

                
            

            

                
                                            returns.push(v261);

            

        

            

                658
            

            

                
            

            

                
                                        }

            

        

            

                659
            

            

                
            

            

                
                                        let v44 = C::fits_in_64(ctx, v2.0);

            

        

            

                660
            

            

                
            

            

                
                                        if let Some(v45) = v44 {

            

        

            

                661
            

            

                
            

            

                
                                            if v19.0 == v45 {

            

        

            

                662
            

            

                
            

            

                
                                                let v10 = C::inst_data_etor(ctx, v7.1);

            

        

            

                663
            

            

                
            

            

                
                                                let mut v10 = v10;

            

        

            

                664
            

            

                
            

            

                
                                                while let Some(v11) = v10.next(ctx) {

            

        

            

                665
            

            

                
            

            

                
                                                    if let &InstructionData::UnaryImm {

            

        

            

                666
            

            

                
            

            

                
                                                        opcode: ref v14,

            

        

            

                667
            

            

                
            

            

                
                                                        imm: v15,

            

        

            

                668
            

            

                
            

            

                
                                                    } = &v11.1

            

        

            

                669
            

            

                
            

            

                
                                                    {

            

        

            

                670
            

            

                
            

            

                
                                                        if let &Opcode::Iconst = v14 {

            

        

            

                671
            

            

                
            

            

                
                                                            if v11.0 == v19.0 {

            

        

            

                672
            

            

                
            

            

                
                                                                let v24 =

            

        

            

                673
            

            

                
            

            

                
                                                                    C::u64_from_imm64(ctx, v23);

            

        

            

                674
            

            

                
            

            

                
                                                                let v16 =

            

        

            

                675
            

            

                
            

            

                
                                                                    C::u64_from_imm64(ctx, v15);

            

        

            

                676
            

            

                
            

            

                
                                                                let v188 =

            

        

            

                677
            

            

                
            

            

                
                                                                    C::u64_add(ctx, v24, v16);

            

        

            

                678
            

            

                
            

            

                
                                                                let v189 =

            

        

            

                679
            

            

                
            

            

                
                                                                    C::imm64_masked(ctx, v45, v188);

            

        

            

                680
            

            

                
            

            

                
                                                                let v190 = constructor_iconst(

            

        

            

                681
            

            

                
            

            

                
                                                                    ctx, v45, v189,

            

        

            

                682
            

            

                
            

            

                
                                                                );

            

        

            

                683
            

            

                
            

            

                
                                                                let v191 = C::subsume(ctx, v190);

            

        

            

                684
            

            

                
            

            

                
                                                                // Rule at src/opts/cprop.isle line 3.

            

        

            

                685
            

            

                
            

            

                
                                                                returns.push(v191);

            

        

            

                686
            

            

                
            

            

                
                                                            }

            

        

            

                687
            

            

                
            

            

                
                                                        }

            

        

            

                688
            

            

                
            

            

                
                                                    }

            

        

            

                689
            

            

                
            

            

                
                                                }

            

        

            

                690
            

            

                
            

            

                
                                            }

            

        

            

                691
            

            

                
            

            

                
                                        }

            

        

            

                692
            

            

                
            

            

                
                                        let v413 = C::remat(ctx, arg0);

            

        

            

                693
            

            

                
            

            

                
                                        // Rule at src/opts/remat.isle line 4.

            

        

            

                694
            

            

                
            

            

                
                                        returns.push(v413);

            

        

            

                695
            

            

                
            

            

                
                                    }

            

        

            

                696
            

            

                
            

            

                
                                }

            

        

            

                697
            

            

                
            

            

                
                                _ => {}

            

        

            

                698
            

            

                
            

            

                
                            }

            

        

            

                699
            

            

                
            

            

                
                        }

            

        

            

                700
            

            

                
            

            

                
                        let v10 = C::inst_data_etor(ctx, v7.1);

            

        

            

                701
            

            

                
            

            

                
                        let mut v10 = v10;

            

        

            

                702
            

            

                
            

            

                
                        while let Some(v11) = v10.next(ctx) {

            

        

            

                703
            

            

                
            

            

                
                            if let &InstructionData::UnaryImm {

            

        

            

                704
            

            

                
            

            

                
                                opcode: ref v14,

            

        

            

                705
            

            

                
            

            

                
                                imm: v15,

            

        

            

                706
            

            

                
            

            

                
                            } = &v11.1

            

        

            

                707
            

            

                
            

            

                
                            {

            

        

            

                708
            

            

                
            

            

                
                                if let &Opcode::Iconst = v14 {

            

        

            

                709
            

            

                
            

            

                
                                    let v16 = C::u64_from_imm64(ctx, v15);

            

        

            

                710
            

            

                
            

            

                
                                    if v16 == 0x0 {

            

        

            

                711
            

            

                
            

            

                
                                        if v2.0 == v11.0 {

            

        

            

                712
            

            

                
            

            

                
                                            let v17 = C::subsume(ctx, v7.0);

            

        

            

                713
            

            

                
            

            

                
                                            // Rule at src/opts/arithmetic.isle line 5.

            

        

            

                714
            

            

                
            

            

                
                                            returns.push(v17);

            

        

            

                715
            

            

                
            

            

                
                                        }

            

        

            

                716
            

            

                
            

            

                
                                    }

            

        

            

                717
            

            

                
            

            

                
                                    let v413 = C::remat(ctx, arg0);

            

        

            

                718
            

            

                
            

            

                
                                    // Rule at src/opts/remat.isle line 6.

            

        

            

                719
            

            

                
            

            

                
                                    returns.push(v413);

            

        

            

                720
            

            

                
            

            

                
                                }

            

        

            

                721
            

            

                
            

            

                
                            }

            

        

            

                722
            

            

                
            

            

                
                        }

            

        

            

                723
            

            

                
            

            

                
                    }

            

        

            

                724
            

            

                
            

            

                
                    &Opcode::Isub => {

            

        

            

                725
            

            

                
            

            

                
                        let v7 = C::unpack_value_array_2(ctx, v6);

            

        

            

                726
            

            

                
            

            

                
                        let v18 = C::inst_data_etor(ctx, v7.0);

            

        

            

                727
            

            

                
            

            

                
                        let mut v18 = v18;

            

        

            

                728
            

            

                
            

            

                
                        while let Some(v19) = v18.next(ctx) {

            

        

            

                729
            

            

                
            

            

                
                            match &v19.1 {

            

        

            

                730
            

            

                
            

            

                
                                &InstructionData::Binary {

            

        

            

                731
            

            

                
            

            

                
                                    opcode: ref v123,

            

        

            

                732
            

            

                
            

            

                
                                    args: ref v124,

            

        

            

                733
            

            

                
            

            

                
                                } => {

            

        

            

                734
            

            

                
            

            

                
                                    match v123 {

            

        

            

                735
            

            

                
            

            

                
                                        &Opcode::Iadd => {

            

        

            

                736
            

            

                
            

            

                
                                            if v2.0 == v19.0 {

            

        

            

                737
            

            

                
            

            

                
                                                let v10 = C::inst_data_etor(ctx, v7.1);

            

        

            

                738
            

            

                
            

            

                
                                                let mut v10 = v10;

            

        

            

                739
            

            

                
            

            

                
                                                while let Some(v11) = v10.next(ctx) {

            

        

            

                740
            

            

                
            

            

                
                                                    if let &InstructionData::UnaryImm {

            

        

            

                741
            

            

                
            

            

                
                                                        opcode: ref v14,

            

        

            

                742
            

            

                
            

            

                
                                                        imm: v15,

            

        

            

                743
            

            

                
            

            

                
                                                    } = &v11.1

            

        

            

                744
            

            

                
            

            

                
                                                    {

            

        

            

                745
            

            

                
            

            

                
                                                        if let &Opcode::Iconst = v14 {

            

        

            

                746
            

            

                
            

            

                
                                                            if v2.0 == v11.0 {

            

        

            

                747
            

            

                
            

            

                
                                                                let v125 = C::unpack_value_array_2(

            

        

            

                748
            

            

                
            

            

                
                                                                    ctx, v124,

            

        

            

                749
            

            

                
            

            

                
                                                                );

            

        

            

                750
            

            

                
            

            

                
                                                                let v135 =

            

        

            

                751
            

            

                
            

            

                
                                                                    C::inst_data_etor(ctx, v125.1);

            

        

            

                752
            

            

                
            

            

                
                                                                let mut v135 = v135;

            

        

            

                753
            

            

                
            

            

                
                                                                while let Some(v136) =

            

        

            

                754
            

            

                
            

            

                
                                                                    v135.next(ctx)

            

        

            

                755
            

            

                
            

            

                
                                                                {

            

        

            

                756
            

            

                
            

            

                
                                                                    if let &InstructionData::UnaryImm {

            

        

            

                757
            

            

                
            

            

                
                                                                        opcode: ref v139,

            

        

            

                758
            

            

                
            

            

                
                                                                        imm: v140,

            

        

            

                759
            

            

                
            

            

                
                                                                    } = &v136.1 {

            

        

            

                760
            

            

                
            

            

                
                                                                        if let &Opcode::Iconst = v139 {

            

        

            

                761
            

            

                
            

            

                
                                                                            if v2.0 == v136.0 {

            

        

            

                762
            

            

                
            

            

                
                                                                                let v16 = C::u64_from_imm64(ctx, v15);

            

        

            

                763
            

            

                
            

            

                
                                                                                let v141 = C::u64_from_imm64(ctx, v140);

            

        

            

                764
            

            

                
            

            

                
                                                                                let v283 = C::u64_sub(ctx, v16, v141);

            

        

            

                765
            

            

                
            

            

                
                                                                                let v284 = C::imm64_masked(ctx, v2.0, v283);

            

        

            

                766
            

            

                
            

            

                
                                                                                let v285 = constructor_iconst(ctx, v2.0, v284);

            

        

            

                767
            

            

                
            

            

                
                                                                                let v286 = constructor_isub(ctx, v2.0, v125.0, v285);

            

        

            

                768
            

            

                
            

            

                
                                                                                // Rule at src/opts/cprop.isle line 143.

            

        

            

                769
            

            

                
            

            

                
                                                                                returns.push(v286);

            

        

            

                770
            

            

                
            

            

                
                                                                            }

            

        

            

                771
            

            

                
            

            

                
                                                                        }

            

        

            

                772
            

            

                
            

            

                
                                                                    }

            

        

            

                773
            

            

                
            

            

                
                                                                }

            

        

            

                774
            

            

                
            

            

                
                                                            }

            

        

            

                775
            

            

                
            

            

                
                                                        }

            

        

            

                776
            

            

                
            

            

                
                                                    }

            

        

            

                777
            

            

                
            

            

                
                                                }

            

        

            

                778
            

            

                
            

            

                
                                            }

            

        

            

                779
            

            

                
            

            

                
                                        }

            

        

            

                780
            

            

                
            

            

                
                                        &Opcode::Isub => {

            

        

            

                781
            

            

                
            

            

                
                                            if v2.0 == v19.0 {

            

        

            

                782
            

            

                
            

            

                
                                                let v10 = C::inst_data_etor(ctx, v7.1);

            

        

            

                783
            

            

                
            

            

                
                                                let mut v10 = v10;

            

        

            

                784
            

            

                
            

            

                
                                                while let Some(v11) = v10.next(ctx) {

            

        

            

                785
            

            

                
            

            

                
                                                    if let &InstructionData::UnaryImm {

            

        

            

                786
            

            

                
            

            

                
                                                        opcode: ref v14,

            

        

            

                787
            

            

                
            

            

                
                                                        imm: v15,

            

        

            

                788
            

            

                
            

            

                
                                                    } = &v11.1

            

        

            

                789
            

            

                
            

            

                
                                                    {

            

        

            

                790
            

            

                
            

            

                
                                                        if let &Opcode::Iconst = v14 {

            

        

            

                791
            

            

                
            

            

                
                                                            if v2.0 == v11.0 {

            

        

            

                792
            

            

                
            

            

                
                                                                let v125 = C::unpack_value_array_2(

            

        

            

                793
            

            

                
            

            

                
                                                                    ctx, v124,

            

        

            

                794
            

            

                
            

            

                
                                                                );

            

        

            

                795
            

            

                
            

            

                
                                                                let v135 =

            

        

            

                796
            

            

                
            

            

                
                                                                    C::inst_data_etor(ctx, v125.1);

            

        

            

                797
            

            

                
            

            

                
                                                                let mut v135 = v135;

            

        

            

                798
            

            

                
            

            

                
                                                                while let Some(v136) =

            

        

            

                799
            

            

                
            

            

                
                                                                    v135.next(ctx)

            

        

            

                800
            

            

                
            

            

                
                                                                {

            

        

            

                801
            

            

                
            

            

                
                                                                    if let &InstructionData::UnaryImm {

            

        

            

                802
            

            

                
            

            

                
                                                                        opcode: ref v139,

            

        

            

                803
            

            

                
            

            

                
                                                                        imm: v140,

            

        

            

                804
            

            

                
            

            

                
                                                                    } = &v136.1 {

            

        

            

                805
            

            

                
            

            

                
                                                                        if let &Opcode::Iconst = v139 {

            

        

            

                806
            

            

                
            

            

                
                                                                            if v2.0 == v136.0 {

            

        

            

                807
            

            

                
            

            

                
                                                                                let v141 = C::u64_from_imm64(ctx, v140);

            

        

            

                808
            

            

                
            

            

                
                                                                                let v16 = C::u64_from_imm64(ctx, v15);

            

        

            

                809
            

            

                
            

            

                
                                                                                let v272 = C::u64_add(ctx, v141, v16);

            

        

            

                810
            

            

                
            

            

                
                                                                                let v273 = C::imm64_masked(ctx, v2.0, v272);

            

        

            

                811
            

            

                
            

            

                
                                                                                let v274 = constructor_iconst(ctx, v2.0, v273);

            

        

            

                812
            

            

                
            

            

                
                                                                                let v275 = constructor_isub(ctx, v2.0, v125.0, v274);

            

        

            

                813
            

            

                
            

            

                
                                                                                // Rule at src/opts/cprop.isle line 135.

            

        

            

                814
            

            

                
            

            

                
                                                                                returns.push(v275);

            

        

            

                815
            

            

                
            

            

                
                                                                            }

            

        

            

                816
            

            

                
            

            

                
                                                                        }

            

        

            

                817
            

            

                
            

            

                
                                                                    }

            

        

            

                818
            

            

                
            

            

                
                                                                }

            

        

            

                819
            

            

                
            

            

                
                                                                let v156 =

            

        

            

                820
            

            

                
            

            

                
                                                                    C::inst_data_etor(ctx, v125.0);

            

        

            

                821
            

            

                
            

            

                
                                                                let mut v156 = v156;

            

        

            

                822
            

            

                
            

            

                
                                                                while let Some(v157) =

            

        

            

                823
            

            

                
            

            

                
                                                                    v156.next(ctx)

            

        

            

                824
            

            

                
            

            

                
                                                                {

            

        

            

                825
            

            

                
            

            

                
                                                                    if let &InstructionData::UnaryImm {

            

        

            

                826
            

            

                
            

            

                
                                                                        opcode: ref v276,

            

        

            

                827
            

            

                
            

            

                
                                                                        imm: v277,

            

        

            

                828
            

            

                
            

            

                
                                                                    } = &v157.1 {

            

        

            

                829
            

            

                
            

            

                
                                                                        if let &Opcode::Iconst = v276 {

            

        

            

                830
            

            

                
            

            

                
                                                                            if v2.0 == v157.0 {

            

        

            

                831
            

            

                
            

            

                
                                                                                let v278 = C::u64_from_imm64(ctx, v277);

            

        

            

                832
            

            

                
            

            

                
                                                                                let v16 = C::u64_from_imm64(ctx, v15);

            

        

            

                833
            

            

                
            

            

                
                                                                                let v279 = C::u64_sub(ctx, v278, v16);

            

        

            

                834
            

            

                
            

            

                
                                                                                let v280 = C::imm64_masked(ctx, v2.0, v279);

            

        

            

                835
            

            

                
            

            

                
                                                                                let v281 = constructor_iconst(ctx, v2.0, v280);

            

        

            

                836
            

            

                
            

            

                
                                                                                let v282 = constructor_isub(ctx, v2.0, v281, v125.1);

            

        

            

                837
            

            

                
            

            

                
                                                                                // Rule at src/opts/cprop.isle line 139.

            

        

            

                838
            

            

                
            

            

                
                                                                                returns.push(v282);

            

        

            

                839
            

            

                
            

            

                
                                                                            }

            

        

            

                840
            

            

                
            

            

                
                                                                        }

            

        

            

                841
            

            

                
            

            

                
                                                                    }

            

        

            

                842
            

            

                
            

            

                
                                                                }

            

        

            

                843
            

            

                
            

            

                
                                                            }

            

        

            

                844
            

            

                
            

            

                
                                                        }

            

        

            

                845
            

            

                
            

            

                
                                                    }

            

        

            

                846
            

            

                
            

            

                
                                                }

            

        

            

                847
            

            

                
            

            

                
                                            }

            

        

            

                848
            

            

                
            

            

                
                                        }

            

        

            

                849
            

            

                
            

            

                
                                        _ => {}

            

        

            

                850
            

            

                
            

            

                
                                    }

            

        

            

                851
            

            

                
            

            

                
                                }

            

        

            

                852
            

            

                
            

            

                
                                &InstructionData::Unary {

            

        

            

                853
            

            

                
            

            

                
                                    opcode: ref v36,

            

        

            

                854
            

            

                
            

            

                
                                    arg: v37,

            

        

            

                855
            

            

                
            

            

                
                                } => {

            

        

            

                856
            

            

                
            

            

                
                                    match v36 {

            

        

            

                857
            

            

                
            

            

                
                                        &Opcode::Splat => {

            

        

            

                858
            

            

                
            

            

                
                                            if v2.0 == v19.0 {

            

        

            

                859
            

            

                
            

            

                
                                                let v10 = C::inst_data_etor(ctx, v7.1);

            

        

            

                860
            

            

                
            

            

                
                                                let mut v10 = v10;

            

        

            

                861
            

            

                
            

            

                
                                                while let Some(v11) = v10.next(ctx) {

            

        

            

                862
            

            

                
            

            

                
                                                    if let &InstructionData::Unary {

            

        

            

                863
            

            

                
            

            

                
                                                        opcode: ref v38,

            

        

            

                864
            

            

                
            

            

                
                                                        arg: v39,

            

        

            

                865
            

            

                
            

            

                
                                                    } = &v11.1

            

        

            

                866
            

            

                
            

            

                
                                                    {

            

        

            

                867
            

            

                
            

            

                
                                                        if let &Opcode::Splat = v38 {

            

        

            

                868
            

            

                
            

            

                
                                                            if v2.0 == v11.0 {

            

        

            

                869
            

            

                
            

            

                
                                                                let v481 = C::lane_type(ctx, v2.0);

            

        

            

                870
            

            

                
            

            

                
                                                                let v498 = constructor_isub(

            

        

            

                871
            

            

                
            

            

                
                                                                    ctx, v481, v37, v39,

            

        

            

                872
            

            

                
            

            

                
                                                                );

            

        

            

                873
            

            

                
            

            

                
                                                                let v499 = constructor_splat(

            

        

            

                874
            

            

                
            

            

                
                                                                    ctx, v2.0, v498,

            

        

            

                875
            

            

                
            

            

                
                                                                );

            

        

            

                876
            

            

                
            

            

                
                                                                // Rule at src/opts/vector.isle line 33.

            

        

            

                877
            

            

                
            

            

                
                                                                returns.push(v499);

            

        

            

                878
            

            

                
            

            

                
                                                            }

            

        

            

                879
            

            

                
            

            

                
                                                        }

            

        

            

                880
            

            

                
            

            

                
                                                    }

            

        

            

                881
            

            

                
            

            

                
                                                }

            

        

            

                882
            

            

                
            

            

                
                                            }

            

        

            

                883
            

            

                
            

            

                
                                        }

            

        

            

                884
            

            

                
            

            

                
                                        &Opcode::Bnot => {

            

        

            

                885
            

            

                
            

            

                
                                            if v2.0 == v19.0 {

            

        

            

                886
            

            

                
            

            

                
                                                let v10 = C::inst_data_etor(ctx, v7.1);

            

        

            

                887
            

            

                
            

            

                
                                                let mut v10 = v10;

            

        

            

                888
            

            

                
            

            

                
                                                while let Some(v11) = v10.next(ctx) {

            

        

            

                889
            

            

                
            

            

                
                                                    if let &InstructionData::UnaryImm {

            

        

            

                890
            

            

                
            

            

                
                                                        opcode: ref v14,

            

        

            

                891
            

            

                
            

            

                
                                                        imm: v15,

            

        

            

                892
            

            

                
            

            

                
                                                    } = &v11.1

            

        

            

                893
            

            

                
            

            

                
                                                    {

            

        

            

                894
            

            

                
            

            

                
                                                        if let &Opcode::Iconst = v14 {

            

        

            

                895
            

            

                
            

            

                
                                                            let v52 = C::i64_sextend_imm64(

            

        

            

                896
            

            

                
            

            

                
                                                                ctx, v2.0, v15,

            

        

            

                897
            

            

                
            

            

                
                                                            );

            

        

            

                898
            

            

                
            

            

                
                                                            if v52 == -0x1 {

            

        

            

                899
            

            

                
            

            

                
                                                                if v2.0 == v11.0 {

            

        

            

                900
            

            

                
            

            

                
                                                                    let v55 = constructor_ineg(

            

        

            

                901
            

            

                
            

            

                
                                                                        ctx, v2.0, v37,

            

        

            

                902
            

            

                
            

            

                
                                                                    );

            

        

            

                903
            

            

                
            

            

                
                                                                    // Rule at src/opts/arithmetic.isle line 75.

            

        

            

                904
            

            

                
            

            

                
                                                                    returns.push(v55);

            

        

            

                905
            

            

                
            

            

                
                                                                }

            

        

            

                906
            

            

                
            

            

                
                                                            }

            

        

            

                907
            

            

                
            

            

                
                                                        }

            

        

            

                908
            

            

                
            

            

                
                                                    }

            

        

            

                909
            

            

                
            

            

                
                                                }

            

        

            

                910
            

            

                
            

            

                
                                            }

            

        

            

                911
            

            

                
            

            

                
                                        }

            

        

            

                912
            

            

                
            

            

                
                                        _ => {}

            

        

            

                913
            

            

                
            

            

                
                                    }

            

        

            

                914
            

            

                
            

            

                
                                }

            

        

            

                915
            

            

                
            

            

                
                                &InstructionData::UnaryImm {

            

        

            

                916
            

            

                
            

            

                
                                    opcode: ref v22,

            

        

            

                917
            

            

                
            

            

                
                                    imm: v23,

            

        

            

                918
            

            

                
            

            

                
                                } => {

            

        

            

                919
            

            

                
            

            

                
                                    if let &Opcode::Iconst = v22 {

            

        

            

                920
            

            

                
            

            

                
                                        if v2.0 == v19.0 {

            

        

            

                921
            

            

                
            

            

                
                                            let v24 = C::u64_from_imm64(ctx, v23);

            

        

            

                922
            

            

                
            

            

                
                                            if v24 == 0x0 {

            

        

            

                923
            

            

                
            

            

                
                                                let v26 = constructor_ineg(ctx, v2.0, v7.1);

            

        

            

                924
            

            

                
            

            

                
                                                // Rule at src/opts/arithmetic.isle line 19.

            

        

            

                925
            

            

                
            

            

                
                                                returns.push(v26);

            

        

            

                926
            

            

                
            

            

                
                                            }

            

        

            

                927
            

            

                
            

            

                
                                            let v262 = constructor_isub(ctx, v2.0, v7.1, v7.0);

            

        

            

                928
            

            

                
            

            

                
                                            let v263 = constructor_ineg(ctx, v2.0, v262);

            

        

            

                929
            

            

                
            

            

                
                                            // Rule at src/opts/cprop.isle line 99.

            

        

            

                930
            

            

                
            

            

                
                                            returns.push(v263);

            

        

            

                931
            

            

                
            

            

                
                                        }

            

        

            

                932
            

            

                
            

            

                
                                        let v44 = C::fits_in_64(ctx, v2.0);

            

        

            

                933
            

            

                
            

            

                
                                        if let Some(v45) = v44 {

            

        

            

                934
            

            

                
            

            

                
                                            if v19.0 == v45 {

            

        

            

                935
            

            

                
            

            

                
                                                let v10 = C::inst_data_etor(ctx, v7.1);

            

        

            

                936
            

            

                
            

            

                
                                                let mut v10 = v10;

            

        

            

                937
            

            

                
            

            

                
                                                while let Some(v11) = v10.next(ctx) {

            

        

            

                938
            

            

                
            

            

                
                                                    if let &InstructionData::UnaryImm {

            

        

            

                939
            

            

                
            

            

                
                                                        opcode: ref v14,

            

        

            

                940
            

            

                
            

            

                
                                                        imm: v15,

            

        

            

                941
            

            

                
            

            

                
                                                    } = &v11.1

            

        

            

                942
            

            

                
            

            

                
                                                    {

            

        

            

                943
            

            

                
            

            

                
                                                        if let &Opcode::Iconst = v14 {

            

        

            

                944
            

            

                
            

            

                
                                                            if v11.0 == v19.0 {

            

        

            

                945
            

            

                
            

            

                
                                                                let v24 =

            

        

            

                946
            

            

                
            

            

                
                                                                    C::u64_from_imm64(ctx, v23);

            

        

            

                947
            

            

                
            

            

                
                                                                let v16 =

            

        

            

                948
            

            

                
            

            

                
                                                                    C::u64_from_imm64(ctx, v15);

            

        

            

                949
            

            

                
            

            

                
                                                                let v192 =

            

        

            

                950
            

            

                
            

            

                
                                                                    C::u64_sub(ctx, v24, v16);

            

        

            

                951
            

            

                
            

            

                
                                                                let v193 =

            

        

            

                952
            

            

                
            

            

                
                                                                    C::imm64_masked(ctx, v45, v192);

            

        

            

                953
            

            

                
            

            

                
                                                                let v194 = constructor_iconst(

            

        

            

                954
            

            

                
            

            

                
                                                                    ctx, v45, v193,

            

        

            

                955
            

            

                
            

            

                
                                                                );

            

        

            

                956
            

            

                
            

            

                
                                                                let v195 = C::subsume(ctx, v194);

            

        

            

                957
            

            

                
            

            

                
                                                                // Rule at src/opts/cprop.isle line 9.

            

        

            

                958
            

            

                
            

            

                
                                                                returns.push(v195);

            

        

            

                959
            

            

                
            

            

                
                                                            }

            

        

            

                960
            

            

                
            

            

                
                                                        }

            

        

            

                961
            

            

                
            

            

                
                                                    }

            

        

            

                962
            

            

                
            

            

                
                                                }

            

        

            

                963
            

            

                
            

            

                
                                            }

            

        

            

                964
            

            

                
            

            

                
                                        }

            

        

            

                965
            

            

                
            

            

                
                                        let v413 = C::remat(ctx, arg0);

            

        

            

                966
            

            

                
            

            

                
                                        // Rule at src/opts/remat.isle line 8.

            

        

            

                967
            

            

                
            

            

                
                                        returns.push(v413);

            

        

            

                968
            

            

                
            

            

                
                                    }

            

        

            

                969
            

            

                
            

            

                
                                }

            

        

            

                970
            

            

                
            

            

                
                                _ => {}

            

        

            

                971
            

            

                
            

            

                
                            }

            

        

            

                972
            

            

                
            

            

                
                        }

            

        

            

                973
            

            

                
            

            

                
                        let v10 = C::inst_data_etor(ctx, v7.1);

            

        

            

                974
            

            

                
            

            

                
                        let mut v10 = v10;

            

        

            

                975
            

            

                
            

            

                
                        while let Some(v11) = v10.next(ctx) {

            

        

            

                976
            

            

                
            

            

                
                            if let &InstructionData::UnaryImm {

            

        

            

                977
            

            

                
            

            

                
                                opcode: ref v14,

            

        

            

                978
            

            

                
            

            

                
                                imm: v15,

            

        

            

                979
            

            

                
            

            

                
                            } = &v11.1

            

        

            

                980
            

            

                
            

            

                
                            {

            

        

            

                981
            

            

                
            

            

                
                                if let &Opcode::Iconst = v14 {

            

        

            

                982
            

            

                
            

            

                
                                    let v16 = C::u64_from_imm64(ctx, v15);

            

        

            

                983
            

            

                
            

            

                
                                    if v16 == 0x0 {

            

        

            

                984
            

            

                
            

            

                
                                        if v2.0 == v11.0 {

            

        

            

                985
            

            

                
            

            

                
                                            let v17 = C::subsume(ctx, v7.0);

            

        

            

                986
            

            

                
            

            

                
                                            // Rule at src/opts/arithmetic.isle line 14.

            

        

            

                987
            

            

                
            

            

                
                                            returns.push(v17);

            

        

            

                988
            

            

                
            

            

                
                                        }

            

        

            

                989
            

            

                
            

            

                
                                    }

            

        

            

                990
            

            

                
            

            

                
                                    let v413 = C::remat(ctx, arg0);

            

        

            

                991
            

            

                
            

            

                
                                    // Rule at src/opts/remat.isle line 10.

            

        

            

                992
            

            

                
            

            

                
                                    returns.push(v413);

            

        

            

                993
            

            

                
            

            

                
                                }

            

        

            

                994
            

            

                
            

            

                
                            }

            

        

            

                995
            

            

                
            

            

                
                        }

            

        

            

                996
            

            

                
            

            

                
                        if v7.0 == v7.1 {

            

        

            

                997
            

            

                
            

            

                
                            let v44 = C::fits_in_64(ctx, v2.0);

            

        

            

                998
            

            

                
            

            

                
                            if let Some(v45) = v44 {

            

        

            

                999
            

            

                
            

            

                
                                let v46 = C::ty_int(ctx, v45);

            

        

            

                1000
            

            

                
            

            

                
                                if let Some(v47) = v46 {

            

        

            

                1001
            

            

                
            

            

                
                                    let v49 = C::imm64(ctx, 0x0);

            

        

            

                1002
            

            

                
            

            

                
                                    let v50 = constructor_iconst(ctx, v47, v49);

            

        

            

                1003
            

            

                
            

            

                
                                    let v51 = C::subsume(ctx, v50);

            

        

            

                1004
            

            

                
            

            

                
                                    // Rule at src/opts/arithmetic.isle line 40.

            

        

            

                1005
            

            

                
            

            

                
                                    returns.push(v51);

            

        

            

                1006
            

            

                
            

            

                
                                }

            

        

            

                1007
            

            

                
            

            

                
                            }

            

        

            

                1008
            

            

                
            

            

                
                        }

            

        

            

                1009
            

            

                
            

            

                
                    }

            

        

            

                1010
            

            

                
            

            

                
                    &Opcode::Imul => {

            

        

            

                1011
            

            

                
            

            

                
                        let v7 = C::unpack_value_array_2(ctx, v6);

            

        

            

                1012
            

            

                
            

            

                
                        let v18 = C::inst_data_etor(ctx, v7.0);

            

        

            

                1013
            

            

                
            

            

                
                        let mut v18 = v18;

            

        

            

                1014
            

            

                
            

            

                
                        while let Some(v19) = v18.next(ctx) {

            

        

            

                1015
            

            

                
            

            

                
                            match &v19.1 {

            

        

            

                1016
            

            

                
            

            

                
                                &InstructionData::Binary {

            

        

            

                1017
            

            

                
            

            

                
                                    opcode: ref v123,

            

        

            

                1018
            

            

                
            

            

                
                                    args: ref v124,

            

        

            

                1019
            

            

                
            

            

                
                                } => {

            

        

            

                1020
            

            

                
            

            

                
                                    if let &Opcode::Imul = v123 {

            

        

            

                1021
            

            

                
            

            

                
                                        if v2.0 == v19.0 {

            

        

            

                1022
            

            

                
            

            

                
                                            let v10 = C::inst_data_etor(ctx, v7.1);

            

        

            

                1023
            

            

                
            

            

                
                                            let mut v10 = v10;

            

        

            

                1024
            

            

                
            

            

                
                                            while let Some(v11) = v10.next(ctx) {

            

        

            

                1025
            

            

                
            

            

                
                                                if let &InstructionData::UnaryImm {

            

        

            

                1026
            

            

                
            

            

                
                                                    opcode: ref v14,

            

        

            

                1027
            

            

                
            

            

                
                                                    imm: v15,

            

        

            

                1028
            

            

                
            

            

                
                                                } = &v11.1

            

        

            

                1029
            

            

                
            

            

                
                                                {

            

        

            

                1030
            

            

                
            

            

                
                                                    if let &Opcode::Iconst = v14 {

            

        

            

                1031
            

            

                
            

            

                
                                                        if v2.0 == v11.0 {

            

        

            

                1032
            

            

                
            

            

                
                                                            let v125 =

            

        

            

                1033
            

            

                
            

            

                
                                                                C::unpack_value_array_2(ctx, v124);

            

        

            

                1034
            

            

                
            

            

                
                                                            let v135 =

            

        

            

                1035
            

            

                
            

            

                
                                                                C::inst_data_etor(ctx, v125.1);

            

        

            

                1036
            

            

                
            

            

                
                                                            let mut v135 = v135;

            

        

            

                1037
            

            

                
            

            

                
                                                            while let Some(v136) = v135.next(ctx) {

            

        

            

                1038
            

            

                
            

            

                
                                                                if let &InstructionData::UnaryImm {

            

        

            

                1039
            

            

                
            

            

                
                                                                    opcode: ref v139,

            

        

            

                1040
            

            

                
            

            

                
                                                                    imm: v140,

            

        

            

                1041
            

            

                
            

            

                
                                                                } = &v136.1 {

            

        

            

                1042
            

            

                
            

            

                
                                                                    if let &Opcode::Iconst = v139 {

            

        

            

                1043
            

            

                
            

            

                
                                                                        if v2.0 == v136.0 {

            

        

            

                1044
            

            

                
            

            

                
                                                                            let v292 = constructor_imul(ctx, v2.0, v125.1, v7.1);

            

        

            

                1045
            

            

                
            

            

                
                                                                            let v293 = constructor_imul(ctx, v2.0, v125.0, v292);

            

        

            

                1046
            

            

                
            

            

                
                                                                            // Rule at src/opts/cprop.isle line 156.

            

        

            

                1047
            

            

                
            

            

                
                                                                            returns.push(v293);

            

        

            

                1048
            

            

                
            

            

                
                                                                        }

            

        

            

                1049
            

            

                
            

            

                
                                                                    }

            

        

            

                1050
            

            

                
            

            

                
                                                                }

            

        

            

                1051
            

            

                
            

            

                
                                                            }

            

        

            

                1052
            

            

                
            

            

                
                                                        }

            

        

            

                1053
            

            

                
            

            

                
                                                    }

            

        

            

                1054
            

            

                
            

            

                
                                                }

            

        

            

                1055
            

            

                
            

            

                
                                            }

            

        

            

                1056
            

            

                
            

            

                
                                        }

            

        

            

                1057
            

            

                
            

            

                
                                    }

            

        

            

                1058
            

            

                
            

            

                
                                }

            

        

            

                1059
            

            

                
            

            

                
                                &InstructionData::Unary {

            

        

            

                1060
            

            

                
            

            

                
                                    opcode: ref v36,

            

        

            

                1061
            

            

                
            

            

                
                                    arg: v37,

            

        

            

                1062
            

            

                
            

            

                
                                } => {

            

        

            

                1063
            

            

                
            

            

                
                                    match v36 {

            

        

            

                1064
            

            

                
            

            

                
                                        &Opcode::Splat => {

            

        

            

                1065
            

            

                
            

            

                
                                            if v2.0 == v19.0 {

            

        

            

                1066
            

            

                
            

            

                
                                                let v10 = C::inst_data_etor(ctx, v7.1);

            

        

            

                1067
            

            

                
            

            

                
                                                let mut v10 = v10;

            

        

            

                1068
            

            

                
            

            

                
                                                while let Some(v11) = v10.next(ctx) {

            

        

            

                1069
            

            

                
            

            

                
                                                    if let &InstructionData::Unary {

            

        

            

                1070
            

            

                
            

            

                
                                                        opcode: ref v38,

            

        

            

                1071
            

            

                
            

            

                
                                                        arg: v39,

            

        

            

                1072
            

            

                
            

            

                
                                                    } = &v11.1

            

        

            

                1073
            

            

                
            

            

                
                                                    {

            

        

            

                1074
            

            

                
            

            

                
                                                        if let &Opcode::Splat = v38 {

            

        

            

                1075
            

            

                
            

            

                
                                                            if v2.0 == v11.0 {

            

        

            

                1076
            

            

                
            

            

                
                                                                let v481 = C::lane_type(ctx, v2.0);

            

        

            

                1077
            

            

                
            

            

                
                                                                let v500 = constructor_imul(

            

        

            

                1078
            

            

                
            

            

                
                                                                    ctx, v481, v37, v39,

            

        

            

                1079
            

            

                
            

            

                
                                                                );

            

        

            

                1080
            

            

                
            

            

                
                                                                let v501 = constructor_splat(

            

        

            

                1081
            

            

                
            

            

                
                                                                    ctx, v2.0, v500,

            

        

            

                1082
            

            

                
            

            

                
                                                                );

            

        

            

                1083
            

            

                
            

            

                
                                                                // Rule at src/opts/vector.isle line 36.

            

        

            

                1084
            

            

                
            

            

                
                                                                returns.push(v501);

            

        

            

                1085
            

            

                
            

            

                
                                                            }

            

        

            

                1086
            

            

                
            

            

                
                                                        }

            

        

            

                1087
            

            

                
            

            

                
                                                    }

            

        

            

                1088
            

            

                
            

            

                
                                                }

            

        

            

                1089
            

            

                
            

            

                
                                            }

            

        

            

                1090
            

            

                
            

            

                
                                        }

            

        

            

                1091
            

            

                
            

            

                
                                        &Opcode::Ineg => {

            

        

            

                1092
            

            

                
            

            

                
                                            if v2.0 == v19.0 {

            

        

            

                1093
            

            

                
            

            

                
                                                let v10 = C::inst_data_etor(ctx, v7.1);

            

        

            

                1094
            

            

                
            

            

                
                                                let mut v10 = v10;

            

        

            

                1095
            

            

                
            

            

                
                                                while let Some(v11) = v10.next(ctx) {

            

        

            

                1096
            

            

                
            

            

                
                                                    if let &InstructionData::Unary {

            

        

            

                1097
            

            

                
            

            

                
                                                        opcode: ref v38,

            

        

            

                1098
            

            

                
            

            

                
                                                        arg: v39,

            

        

            

                1099
            

            

                
            

            

                
                                                    } = &v11.1

            

        

            

                1100
            

            

                
            

            

                
                                                    {

            

        

            

                1101
            

            

                
            

            

                
                                                        if let &Opcode::Ineg = v38 {

            

        

            

                1102
            

            

                
            

            

                
                                                            if v2.0 == v11.0 {

            

        

            

                1103
            

            

                
            

            

                
                                                                let v40 = constructor_imul(

            

        

            

                1104
            

            

                
            

            

                
                                                                    ctx, v2.0, v37, v39,

            

        

            

                1105
            

            

                
            

            

                
                                                                );

            

        

            

                1106
            

            

                
            

            

                
                                                                let v41 = C::subsume(ctx, v40);

            

        

            

                1107
            

            

                
            

            

                
                                                                // Rule at src/opts/arithmetic.isle line 28.

            

        

            

                1108
            

            

                
            

            

                
                                                                returns.push(v41);

            

        

            

                1109
            

            

                
            

            

                
                                                            }

            

        

            

                1110
            

            

                
            

            

                
                                                        }

            

        

            

                1111
            

            

                
            

            

                
                                                    }

            

        

            

                1112
            

            

                
            

            

                
                                                }

            

        

            

                1113
            

            

                
            

            

                
                                            }

            

        

            

                1114
            

            

                
            

            

                
                                        }

            

        

            

                1115
            

            

                
            

            

                
                                        _ => {}

            

        

            

                1116
            

            

                
            

            

                
                                    }

            

        

            

                1117
            

            

                
            

            

                
                                }

            

        

            

                1118
            

            

                
            

            

                
                                &InstructionData::UnaryImm {

            

        

            

                1119
            

            

                
            

            

                
                                    opcode: ref v22,

            

        

            

                1120
            

            

                
            

            

                
                                    imm: v23,

            

        

            

                1121
            

            

                
            

            

                
                                } => {

            

        

            

                1122
            

            

                
            

            

                
                                    if let &Opcode::Iconst = v22 {

            

        

            

                1123
            

            

                
            

            

                
                                        if v2.0 == v19.0 {

            

        

            

                1124
            

            

                
            

            

                
                                            let v24 = C::u64_from_imm64(ctx, v23);

            

        

            

                1125
            

            

                
            

            

                
                                            match v24 {

            

        

            

                1126
            

            

                
            

            

                
                                                0x0 => {

            

        

            

                1127
            

            

                
            

            

                
                                                    let v17 = C::subsume(ctx, v7.0);

            

        

            

                1128
            

            

                
            

            

                
                                                    // Rule at src/opts/arithmetic.isle line 57.

            

        

            

                1129
            

            

                
            

            

                
                                                    returns.push(v17);

            

        

            

                1130
            

            

                
            

            

                
                                                }

            

        

            

                1131
            

            

                
            

            

                
                                                0x1 => {

            

        

            

                1132
            

            

                
            

            

                
                                                    let v25 = C::subsume(ctx, v7.1);

            

        

            

                1133
            

            

                
            

            

                
                                                    // Rule at src/opts/arithmetic.isle line 47.

            

        

            

                1134
            

            

                
            

            

                
                                                    returns.push(v25);

            

        

            

                1135
            

            

                
            

            

                
                                                }

            

        

            

                1136
            

            

                
            

            

                
                                                _ => {}

            

        

            

                1137
            

            

                
            

            

                
                                            }

            

        

            

                1138
            

            

                
            

            

                
                                            let v54 = C::i64_sextend_imm64(ctx, v2.0, v23);

            

        

            

                1139
            

            

                
            

            

                
                                            if v54 == -0x1 {

            

        

            

                1140
            

            

                
            

            

                
                                                let v26 = constructor_ineg(ctx, v2.0, v7.1);

            

        

            

                1141
            

            

                
            

            

                
                                                // Rule at src/opts/arithmetic.isle line 66.

            

        

            

                1142
            

            

                
            

            

                
                                                returns.push(v26);

            

        

            

                1143
            

            

                
            

            

                
                                            }

            

        

            

                1144
            

            

                
            

            

                
                                            let v264 = constructor_imul(ctx, v2.0, v7.1, v7.0);

            

        

            

                1145
            

            

                
            

            

                
                                            // Rule at src/opts/cprop.isle line 102.

            

        

            

                1146
            

            

                
            

            

                
                                            returns.push(v264);

            

        

            

                1147
            

            

                
            

            

                
                                        }

            

        

            

                1148
            

            

                
            

            

                
                                        let v44 = C::fits_in_64(ctx, v2.0);

            

        

            

                1149
            

            

                
            

            

                
                                        if let Some(v45) = v44 {

            

        

            

                1150
            

            

                
            

            

                
                                            if v19.0 == v45 {

            

        

            

                1151
            

            

                
            

            

                
                                                let v10 = C::inst_data_etor(ctx, v7.1);

            

        

            

                1152
            

            

                
            

            

                
                                                let mut v10 = v10;

            

        

            

                1153
            

            

                
            

            

                
                                                while let Some(v11) = v10.next(ctx) {

            

        

            

                1154
            

            

                
            

            

                
                                                    if let &InstructionData::UnaryImm {

            

        

            

                1155
            

            

                
            

            

                
                                                        opcode: ref v14,

            

        

            

                1156
            

            

                
            

            

                
                                                        imm: v15,

            

        

            

                1157
            

            

                
            

            

                
                                                    } = &v11.1

            

        

            

                1158
            

            

                
            

            

                
                                                    {

            

        

            

                1159
            

            

                
            

            

                
                                                        if let &Opcode::Iconst = v14 {

            

        

            

                1160
            

            

                
            

            

                
                                                            if v11.0 == v19.0 {

            

        

            

                1161
            

            

                
            

            

                
                                                                let v24 =

            

        

            

                1162
            

            

                
            

            

                
                                                                    C::u64_from_imm64(ctx, v23);

            

        

            

                1163
            

            

                
            

            

                
                                                                let v16 =

            

        

            

                1164
            

            

                
            

            

                
                                                                    C::u64_from_imm64(ctx, v15);

            

        

            

                1165
            

            

                
            

            

                
                                                                let v196 =

            

        

            

                1166
            

            

                
            

            

                
                                                                    C::u64_mul(ctx, v24, v16);

            

        

            

                1167
            

            

                
            

            

                
                                                                let v197 =

            

        

            

                1168
            

            

                
            

            

                
                                                                    C::imm64_masked(ctx, v45, v196);

            

        

            

                1169
            

            

                
            

            

                
                                                                let v198 = constructor_iconst(

            

        

            

                1170
            

            

                
            

            

                
                                                                    ctx, v45, v197,

            

        

            

                1171
            

            

                
            

            

                
                                                                );

            

        

            

                1172
            

            

                
            

            

                
                                                                let v199 = C::subsume(ctx, v198);

            

        

            

                1173
            

            

                
            

            

                
                                                                // Rule at src/opts/cprop.isle line 15.

            

        

            

                1174
            

            

                
            

            

                
                                                                returns.push(v199);

            

        

            

                1175
            

            

                
            

            

                
                                                            }

            

        

            

                1176
            

            

                
            

            

                
                                                        }

            

        

            

                1177
            

            

                
            

            

                
                                                    }

            

        

            

                1178
            

            

                
            

            

                
                                                }

            

        

            

                1179
            

            

                
            

            

                
                                            }

            

        

            

                1180
            

            

                
            

            

                
                                        }

            

        

            

                1181
            

            

                
            

            

                
                                        let v82 = C::simm32(ctx, v23);

            

        

            

                1182
            

            

                
            

            

                
                                        if let Some(v83) = v82 {

            

        

            

                1183
            

            

                
            

            

                
                                            if v83 == 0x2 {

            

        

            

                1184
            

            

                
            

            

                
                                                let v84 = constructor_iadd(ctx, v2.0, v7.1, v7.1);

            

        

            

                1185
            

            

                
            

            

                
                                                // Rule at src/opts/arithmetic.isle line 105.

            

        

            

                1186
            

            

                
            

            

                
                                                returns.push(v84);

            

        

            

                1187
            

            

                
            

            

                
                                            }

            

        

            

                1188
            

            

                
            

            

                
                                        }

            

        

            

                1189
            

            

                
            

            

                
                                        let v90 = C::imm64_power_of_two(ctx, v23);

            

        

            

                1190
            

            

                
            

            

                
                                        if let Some(v91) = v90 {

            

        

            

                1191
            

            

                
            

            

                
                                            let v92 = C::imm64(ctx, v91);

            

        

            

                1192
            

            

                
            

            

                
                                            let v93 = constructor_iconst(ctx, v2.0, v92);

            

        

            

                1193
            

            

                
            

            

                
                                            let v94 = constructor_ishl(ctx, v2.0, v7.1, v93);

            

        

            

                1194
            

            

                
            

            

                
                                            // Rule at src/opts/arithmetic.isle line 114.

            

        

            

                1195
            

            

                
            

            

                
                                            returns.push(v94);

            

        

            

                1196
            

            

                
            

            

                
                                        }

            

        

            

                1197
            

            

                
            

            

                
                                    }

            

        

            

                1198
            

            

                
            

            

                
                                }

            

        

            

                1199
            

            

                
            

            

                
                                _ => {}

            

        

            

                1200
            

            

                
            

            

                
                            }

            

        

            

                1201
            

            

                
            

            

                
                        }

            

        

            

                1202
            

            

                
            

            

                
                        let v10 = C::inst_data_etor(ctx, v7.1);

            

        

            

                1203
            

            

                
            

            

                
                        let mut v10 = v10;

            

        

            

                1204
            

            

                
            

            

                
                        while let Some(v11) = v10.next(ctx) {

            

        

            

                1205
            

            

                
            

            

                
                            if let &InstructionData::UnaryImm {

            

        

            

                1206
            

            

                
            

            

                
                                opcode: ref v14,

            

        

            

                1207
            

            

                
            

            

                
                                imm: v15,

            

        

            

                1208
            

            

                
            

            

                
                            } = &v11.1

            

        

            

                1209
            

            

                
            

            

                
                            {

            

        

            

                1210
            

            

                
            

            

                
                                if let &Opcode::Iconst = v14 {

            

        

            

                1211
            

            

                
            

            

                
                                    if v2.0 == v11.0 {

            

        

            

                1212
            

            

                
            

            

                
                                        let v16 = C::u64_from_imm64(ctx, v15);

            

        

            

                1213
            

            

                
            

            

                
                                        match v16 {

            

        

            

                1214
            

            

                
            

            

                
                                            0x0 => {

            

        

            

                1215
            

            

                
            

            

                
                                                let v25 = C::subsume(ctx, v7.1);

            

        

            

                1216
            

            

                
            

            

                
                                                // Rule at src/opts/arithmetic.isle line 53.

            

        

            

                1217
            

            

                
            

            

                
                                                returns.push(v25);

            

        

            

                1218
            

            

                
            

            

                
                                            }

            

        

            

                1219
            

            

                
            

            

                
                                            0x1 => {

            

        

            

                1220
            

            

                
            

            

                
                                                let v17 = C::subsume(ctx, v7.0);

            

        

            

                1221
            

            

                
            

            

                
                                                // Rule at src/opts/arithmetic.isle line 43.

            

        

            

                1222
            

            

                
            

            

                
                                                returns.push(v17);

            

        

            

                1223
            

            

                
            

            

                
                                            }

            

        

            

                1224
            

            

                
            

            

                
                                            _ => {}

            

        

            

                1225
            

            

                
            

            

                
                                        }

            

        

            

                1226
            

            

                
            

            

                
                                        let v52 = C::i64_sextend_imm64(ctx, v2.0, v15);

            

        

            

                1227
            

            

                
            

            

                
                                        if v52 == -0x1 {

            

        

            

                1228
            

            

                
            

            

                
                                            let v53 = constructor_ineg(ctx, v2.0, v7.0);

            

        

            

                1229
            

            

                
            

            

                
                                            // Rule at src/opts/arithmetic.isle line 63.

            

        

            

                1230
            

            

                
            

            

                
                                            returns.push(v53);

            

        

            

                1231
            

            

                
            

            

                
                                        }

            

        

            

                1232
            

            

                
            

            

                
                                    }

            

        

            

                1233
            

            

                
            

            

                
                                    let v79 = C::simm32(ctx, v15);

            

        

            

                1234
            

            

                
            

            

                
                                    if let Some(v80) = v79 {

            

        

            

                1235
            

            

                
            

            

                
                                        if v80 == 0x2 {

            

        

            

                1236
            

            

                
            

            

                
                                            let v81 = constructor_iadd(ctx, v2.0, v7.0, v7.0);

            

        

            

                1237
            

            

                
            

            

                
                                            // Rule at src/opts/arithmetic.isle line 103.

            

        

            

                1238
            

            

                
            

            

                
                                            returns.push(v81);

            

        

            

                1239
            

            

                
            

            

                
                                        }

            

        

            

                1240
            

            

                
            

            

                
                                    }

            

        

            

                1241
            

            

                
            

            

                
                                    let v85 = C::imm64_power_of_two(ctx, v15);

            

        

            

                1242
            

            

                
            

            

                
                                    if let Some(v86) = v85 {

            

        

            

                1243
            

            

                
            

            

                
                                        let v87 = C::imm64(ctx, v86);

            

        

            

                1244
            

            

                
            

            

                
                                        let v88 = constructor_iconst(ctx, v2.0, v87);

            

        

            

                1245
            

            

                
            

            

                
                                        let v89 = constructor_ishl(ctx, v2.0, v7.0, v88);

            

        

            

                1246
            

            

                
            

            

                
                                        // Rule at src/opts/arithmetic.isle line 112.

            

        

            

                1247
            

            

                
            

            

                
                                        returns.push(v89);

            

        

            

                1248
            

            

                
            

            

                
                                    }

            

        

            

                1249
            

            

                
            

            

                
                                }

            

        

            

                1250
            

            

                
            

            

                
                            }

            

        

            

                1251
            

            

                
            

            

                
                        }

            

        

            

                1252
            

            

                
            

            

                
                    }

            

        

            

                1253
            

            

                
            

            

                
                    &Opcode::Umulhi => {

            

        

            

                1254
            

            

                
            

            

                
                        let v7 = C::unpack_value_array_2(ctx, v6);

            

        

            

                1255
            

            

                
            

            

                
                        let v10 = C::inst_data_etor(ctx, v7.1);

            

        

            

                1256
            

            

                
            

            

                
                        let mut v10 = v10;

            

        

            

                1257
            

            

                
            

            

                
                        while let Some(v11) = v10.next(ctx) {

            

        

            

                1258
            

            

                
            

            

                
                            if let &InstructionData::Unary {

            

        

            

                1259
            

            

                
            

            

                
                                opcode: ref v38,

            

        

            

                1260
            

            

                
            

            

                
                                arg: v39,

            

        

            

                1261
            

            

                
            

            

                
                            } = &v11.1

            

        

            

                1262
            

            

                
            

            

                
                            {

            

        

            

                1263
            

            

                
            

            

                
                                if let &Opcode::Splat = v38 {

            

        

            

                1264
            

            

                
            

            

                
                                    if v2.0 == v11.0 {

            

        

            

                1265
            

            

                
            

            

                
                                        let v18 = C::inst_data_etor(ctx, v7.0);

            

        

            

                1266
            

            

                
            

            

                
                                        let mut v18 = v18;

            

        

            

                1267
            

            

                
            

            

                
                                        while let Some(v19) = v18.next(ctx) {

            

        

            

                1268
            

            

                
            

            

                
                                            if let &InstructionData::Unary {

            

        

            

                1269
            

            

                
            

            

                
                                                opcode: ref v36,

            

        

            

                1270
            

            

                
            

            

                
                                                arg: v37,

            

        

            

                1271
            

            

                
            

            

                
                                            } = &v19.1

            

        

            

                1272
            

            

                
            

            

                
                                            {

            

        

            

                1273
            

            

                
            

            

                
                                                if let &Opcode::Splat = v36 {

            

        

            

                1274
            

            

                
            

            

                
                                                    if v2.0 == v19.0 {

            

        

            

                1275
            

            

                
            

            

                
                                                        let v481 = C::lane_type(ctx, v2.0);

            

        

            

                1276
            

            

                
            

            

                
                                                        let v504 =

            

        

            

                1277
            

            

                
            

            

                
                                                            constructor_umulhi(ctx, v481, v37, v39);

            

        

            

                1278
            

            

                
            

            

                
                                                        let v505 =

            

        

            

                1279
            

            

                
            

            

                
                                                            constructor_splat(ctx, v2.0, v504);

            

        

            

                1280
            

            

                
            

            

                
                                                        // Rule at src/opts/vector.isle line 42.

            

        

            

                1281
            

            

                
            

            

                
                                                        returns.push(v505);

            

        

            

                1282
            

            

                
            

            

                
                                                    }

            

        

            

                1283
            

            

                
            

            

                
                                                }

            

        

            

                1284
            

            

                
            

            

                
                                            }

            

        

            

                1285
            

            

                
            

            

                
                                        }

            

        

            

                1286
            

            

                
            

            

                
                                    }

            

        

            

                1287
            

            

                
            

            

                
                                }

            

        

            

                1288
            

            

                
            

            

                
                            }

            

        

            

                1289
            

            

                
            

            

                
                        }

            

        

            

                1290
            

            

                
            

            

                
                    }

            

        

            

                1291
            

            

                
            

            

                
                    &Opcode::Smulhi => {

            

        

            

                1292
            

            

                
            

            

                
                        let v7 = C::unpack_value_array_2(ctx, v6);

            

        

            

                1293
            

            

                
            

            

                
                        let v10 = C::inst_data_etor(ctx, v7.1);

            

        

            

                1294
            

            

                
            

            

                
                        let mut v10 = v10;

            

        

            

                1295
            

            

                
            

            

                
                        while let Some(v11) = v10.next(ctx) {

            

        

            

                1296
            

            

                
            

            

                
                            if let &InstructionData::Unary {

            

        

            

                1297
            

            

                
            

            

                
                                opcode: ref v38,

            

        

            

                1298
            

            

                
            

            

                
                                arg: v39,

            

        

            

                1299
            

            

                
            

            

                
                            } = &v11.1

            

        

            

                1300
            

            

                
            

            

                
                            {

            

        

            

                1301
            

            

                
            

            

                
                                if let &Opcode::Splat = v38 {

            

        

            

                1302
            

            

                
            

            

                
                                    if v2.0 == v11.0 {

            

        

            

                1303
            

            

                
            

            

                
                                        let v18 = C::inst_data_etor(ctx, v7.0);

            

        

            

                1304
            

            

                
            

            

                
                                        let mut v18 = v18;

            

        

            

                1305
            

            

                
            

            

                
                                        while let Some(v19) = v18.next(ctx) {

            

        

            

                1306
            

            

                
            

            

                
                                            if let &InstructionData::Unary {

            

        

            

                1307
            

            

                
            

            

                
                                                opcode: ref v36,

            

        

            

                1308
            

            

                
            

            

                
                                                arg: v37,

            

        

            

                1309
            

            

                
            

            

                
                                            } = &v19.1

            

        

            

                1310
            

            

                
            

            

                
                                            {

            

        

            

                1311
            

            

                
            

            

                
                                                if let &Opcode::Splat = v36 {

            

        

            

                1312
            

            

                
            

            

                
                                                    if v2.0 == v19.0 {

            

        

            

                1313
            

            

                
            

            

                
                                                        let v481 = C::lane_type(ctx, v2.0);

            

        

            

                1314
            

            

                
            

            

                
                                                        let v502 =

            

        

            

                1315
            

            

                
            

            

                
                                                            constructor_smulhi(ctx, v481, v37, v39);

            

        

            

                1316
            

            

                
            

            

                
                                                        let v503 =

            

        

            

                1317
            

            

                
            

            

                
                                                            constructor_splat(ctx, v2.0, v502);

            

        

            

                1318
            

            

                
            

            

                
                                                        // Rule at src/opts/vector.isle line 39.

            

        

            

                1319
            

            

                
            

            

                
                                                        returns.push(v503);

            

        

            

                1320
            

            

                
            

            

                
                                                    }

            

        

            

                1321
            

            

                
            

            

                
                                                }

            

        

            

                1322
            

            

                
            

            

                
                                            }

            

        

            

                1323
            

            

                
            

            

                
                                        }

            

        

            

                1324
            

            

                
            

            

                
                                    }

            

        

            

                1325
            

            

                
            

            

                
                                }

            

        

            

                1326
            

            

                
            

            

                
                            }

            

        

            

                1327
            

            

                
            

            

                
                        }

            

        

            

                1328
            

            

                
            

            

                
                    }

            

        

            

                1329
            

            

                
            

            

                
                    &Opcode::Udiv => {

            

        

            

                1330
            

            

                
            

            

                
                        let v7 = C::unpack_value_array_2(ctx, v6);

            

        

            

                1331
            

            

                
            

            

                
                        let v10 = C::inst_data_etor(ctx, v7.1);

            

        

            

                1332
            

            

                
            

            

                
                        let mut v10 = v10;

            

        

            

                1333
            

            

                
            

            

                
                        while let Some(v11) = v10.next(ctx) {

            

        

            

                1334
            

            

                
            

            

                
                            if let &InstructionData::UnaryImm {

            

        

            

                1335
            

            

                
            

            

                
                                opcode: ref v14,

            

        

            

                1336
            

            

                
            

            

                
                                imm: v15,

            

        

            

                1337
            

            

                
            

            

                
                            } = &v11.1

            

        

            

                1338
            

            

                
            

            

                
                            {

            

        

            

                1339
            

            

                
            

            

                
                                if let &Opcode::Iconst = v14 {

            

        

            

                1340
            

            

                
            

            

                
                                    let v16 = C::u64_from_imm64(ctx, v15);

            

        

            

                1341
            

            

                
            

            

                
                                    if v16 == 0x1 {

            

        

            

                1342
            

            

                
            

            

                
                                        if v2.0 == v11.0 {

            

        

            

                1343
            

            

                
            

            

                
                                            let v17 = C::subsume(ctx, v7.0);

            

        

            

                1344
            

            

                
            

            

                
                                            // Rule at src/opts/arithmetic.isle line 94.

            

        

            

                1345
            

            

                
            

            

                
                                            returns.push(v17);

            

        

            

                1346
            

            

                
            

            

                
                                        }

            

        

            

                1347
            

            

                
            

            

                
                                    }

            

        

            

                1348
            

            

                
            

            

                
                                    let v44 = C::fits_in_64(ctx, v2.0);

            

        

            

                1349
            

            

                
            

            

                
                                    if let Some(v45) = v44 {

            

        

            

                1350
            

            

                
            

            

                
                                        if v11.0 == v45 {

            

        

            

                1351
            

            

                
            

            

                
                                            let v18 = C::inst_data_etor(ctx, v7.0);

            

        

            

                1352
            

            

                
            

            

                
                                            let mut v18 = v18;

            

        

            

                1353
            

            

                
            

            

                
                                            while let Some(v19) = v18.next(ctx) {

            

        

            

                1354
            

            

                
            

            

                
                                                if let &InstructionData::UnaryImm {

            

        

            

                1355
            

            

                
            

            

                
                                                    opcode: ref v22,

            

        

            

                1356
            

            

                
            

            

                
                                                    imm: v23,

            

        

            

                1357
            

            

                
            

            

                
                                                } = &v19.1

            

        

            

                1358
            

            

                
            

            

                
                                                {

            

        

            

                1359
            

            

                
            

            

                
                                                    if let &Opcode::Iconst = v22 {

            

        

            

                1360
            

            

                
            

            

                
                                                        let v24 = C::u64_from_imm64(ctx, v23);

            

        

            

                1361
            

            

                
            

            

                
                                                        let v205 = C::u64_udiv(ctx, v24, v16);

            

        

            

                1362
            

            

                
            

            

                
                                                        if let Some(v206) = v205 {

            

        

            

                1363
            

            

                
            

            

                
                                                            if v11.0 == v19.0 {

            

        

            

                1364
            

            

                
            

            

                
                                                                let v207 =

            

        

            

                1365
            

            

                
            

            

                
                                                                    C::imm64_masked(ctx, v45, v206);

            

        

            

                1366
            

            

                
            

            

                
                                                                let v208 = constructor_iconst(

            

        

            

                1367
            

            

                
            

            

                
                                                                    ctx, v45, v207,

            

        

            

                1368
            

            

                
            

            

                
                                                                );

            

        

            

                1369
            

            

                
            

            

                
                                                                let v209 = C::subsume(ctx, v208);

            

        

            

                1370
            

            

                
            

            

                
                                                                // Rule at src/opts/cprop.isle line 28.

            

        

            

                1371
            

            

                
            

            

                
                                                                returns.push(v209);

            

        

            

                1372
            

            

                
            

            

                
                                                            }

            

        

            

                1373
            

            

                
            

            

                
                                                        }

            

        

            

                1374
            

            

                
            

            

                
                                                    }

            

        

            

                1375
            

            

                
            

            

                
                                                }

            

        

            

                1376
            

            

                
            

            

                
                                            }

            

        

            

                1377
            

            

                
            

            

                
                                        }

            

        

            

                1378
            

            

                
            

            

                
                                    }

            

        

            

                1379
            

            

                
            

            

                
                                }

            

        

            

                1380
            

            

                
            

            

                
                            }

            

        

            

                1381
            

            

                
            

            

                
                        }

            

        

            

                1382
            

            

                
            

            

                
                    }

            

        

            

                1383
            

            

                
            

            

                
                    &Opcode::Sdiv => {

            

        

            

                1384
            

            

                
            

            

                
                        let v7 = C::unpack_value_array_2(ctx, v6);

            

        

            

                1385
            

            

                
            

            

                
                        let v10 = C::inst_data_etor(ctx, v7.1);

            

        

            

                1386
            

            

                
            

            

                
                        let mut v10 = v10;

            

        

            

                1387
            

            

                
            

            

                
                        while let Some(v11) = v10.next(ctx) {

            

        

            

                1388
            

            

                
            

            

                
                            if let &InstructionData::UnaryImm {

            

        

            

                1389
            

            

                
            

            

                
                                opcode: ref v14,

            

        

            

                1390
            

            

                
            

            

                
                                imm: v15,

            

        

            

                1391
            

            

                
            

            

                
                            } = &v11.1

            

        

            

                1392
            

            

                
            

            

                
                            {

            

        

            

                1393
            

            

                
            

            

                
                                if let &Opcode::Iconst = v14 {

            

        

            

                1394
            

            

                
            

            

                
                                    let v16 = C::u64_from_imm64(ctx, v15);

            

        

            

                1395
            

            

                
            

            

                
                                    if v16 == 0x1 {

            

        

            

                1396
            

            

                
            

            

                
                                        if v2.0 == v11.0 {

            

        

            

                1397
            

            

                
            

            

                
                                            let v17 = C::subsume(ctx, v7.0);

            

        

            

                1398
            

            

                
            

            

                
                                            // Rule at src/opts/arithmetic.isle line 90.

            

        

            

                1399
            

            

                
            

            

                
                                            returns.push(v17);

            

        

            

                1400
            

            

                
            

            

                
                                        }

            

        

            

                1401
            

            

                
            

            

                
                                    }

            

        

            

                1402
            

            

                
            

            

                
                                    let v44 = C::fits_in_64(ctx, v2.0);

            

        

            

                1403
            

            

                
            

            

                
                                    if let Some(v45) = v44 {

            

        

            

                1404
            

            

                
            

            

                
                                        if v11.0 == v45 {

            

        

            

                1405
            

            

                
            

            

                
                                            let v18 = C::inst_data_etor(ctx, v7.0);

            

        

            

                1406
            

            

                
            

            

                
                                            let mut v18 = v18;

            

        

            

                1407
            

            

                
            

            

                
                                            while let Some(v19) = v18.next(ctx) {

            

        

            

                1408
            

            

                
            

            

                
                                                if let &InstructionData::UnaryImm {

            

        

            

                1409
            

            

                
            

            

                
                                                    opcode: ref v22,

            

        

            

                1410
            

            

                
            

            

                
                                                    imm: v23,

            

        

            

                1411
            

            

                
            

            

                
                                                } = &v19.1

            

        

            

                1412
            

            

                
            

            

                
                                                {

            

        

            

                1413
            

            

                
            

            

                
                                                    if let &Opcode::Iconst = v22 {

            

        

            

                1414
            

            

                
            

            

                
                                                        let v24 = C::u64_from_imm64(ctx, v23);

            

        

            

                1415
            

            

                
            

            

                
                                                        let v200 = C::u64_sdiv(ctx, v24, v16);

            

        

            

                1416
            

            

                
            

            

                
                                                        if let Some(v201) = v200 {

            

        

            

                1417
            

            

                
            

            

                
                                                            if v11.0 == v19.0 {

            

        

            

                1418
            

            

                
            

            

                
                                                                let v202 =

            

        

            

                1419
            

            

                
            

            

                
                                                                    C::imm64_masked(ctx, v45, v201);

            

        

            

                1420
            

            

                
            

            

                
                                                                let v203 = constructor_iconst(

            

        

            

                1421
            

            

                
            

            

                
                                                                    ctx, v45, v202,

            

        

            

                1422
            

            

                
            

            

                
                                                                );

            

        

            

                1423
            

            

                
            

            

                
                                                                let v204 = C::subsume(ctx, v203);

            

        

            

                1424
            

            

                
            

            

                
                                                                // Rule at src/opts/cprop.isle line 21.

            

        

            

                1425
            

            

                
            

            

                
                                                                returns.push(v204);

            

        

            

                1426
            

            

                
            

            

                
                                                            }

            

        

            

                1427
            

            

                
            

            

                
                                                        }

            

        

            

                1428
            

            

                
            

            

                
                                                    }

            

        

            

                1429
            

            

                
            

            

                
                                                }

            

        

            

                1430
            

            

                
            

            

                
                                            }

            

        

            

                1431
            

            

                
            

            

                
                                        }

            

        

            

                1432
            

            

                
            

            

                
                                    }

            

        

            

                1433
            

            

                
            

            

                
                                }

            

        

            

                1434
            

            

                
            

            

                
                            }

            

        

            

                1435
            

            

                
            

            

                
                        }

            

        

            

                1436
            

            

                
            

            

                
                    }

            

        

            

                1437
            

            

                
            

            

                
                    &Opcode::Band => {

            

        

            

                1438
            

            

                
            

            

                
                        let v7 = C::unpack_value_array_2(ctx, v6);

            

        

            

                1439
            

            

                
            

            

                
                        let v18 = C::inst_data_etor(ctx, v7.0);

            

        

            

                1440
            

            

                
            

            

                
                        let mut v18 = v18;

            

        

            

                1441
            

            

                
            

            

                
                        while let Some(v19) = v18.next(ctx) {

            

        

            

                1442
            

            

                
            

            

                
                            match &v19.1 {

            

        

            

                1443
            

            

                
            

            

                
                                &InstructionData::Binary {

            

        

            

                1444
            

            

                
            

            

                
                                    opcode: ref v123,

            

        

            

                1445
            

            

                
            

            

                
                                    args: ref v124,

            

        

            

                1446
            

            

                
            

            

                
                                } => {

            

        

            

                1447
            

            

                
            

            

                
                                    if let &Opcode::Band = v123 {

            

        

            

                1448
            

            

                
            

            

                
                                        if v2.0 == v19.0 {

            

        

            

                1449
            

            

                
            

            

                
                                            let v10 = C::inst_data_etor(ctx, v7.1);

            

        

            

                1450
            

            

                
            

            

                
                                            let mut v10 = v10;

            

        

            

                1451
            

            

                
            

            

                
                                            while let Some(v11) = v10.next(ctx) {

            

        

            

                1452
            

            

                
            

            

                
                                                if let &InstructionData::UnaryImm {

            

        

            

                1453
            

            

                
            

            

                
                                                    opcode: ref v14,

            

        

            

                1454
            

            

                
            

            

                
                                                    imm: v15,

            

        

            

                1455
            

            

                
            

            

                
                                                } = &v11.1

            

        

            

                1456
            

            

                
            

            

                
                                                {

            

        

            

                1457
            

            

                
            

            

                
                                                    if let &Opcode::Iconst = v14 {

            

        

            

                1458
            

            

                
            

            

                
                                                        if v2.0 == v11.0 {

            

        

            

                1459
            

            

                
            

            

                
                                                            let v125 =

            

        

            

                1460
            

            

                
            

            

                
                                                                C::unpack_value_array_2(ctx, v124);

            

        

            

                1461
            

            

                
            

            

                
                                                            let v135 =

            

        

            

                1462
            

            

                
            

            

                
                                                                C::inst_data_etor(ctx, v125.1);

            

        

            

                1463
            

            

                
            

            

                
                                                            let mut v135 = v135;

            

        

            

                1464
            

            

                
            

            

                
                                                            while let Some(v136) = v135.next(ctx) {

            

        

            

                1465
            

            

                
            

            

                
                                                                if let &InstructionData::UnaryImm {

            

        

            

                1466
            

            

                
            

            

                
                                                                    opcode: ref v139,

            

        

            

                1467
            

            

                
            

            

                
                                                                    imm: v140,

            

        

            

                1468
            

            

                
            

            

                
                                                                } = &v136.1 {

            

        

            

                1469
            

            

                
            

            

                
                                                                    if let &Opcode::Iconst = v139 {

            

        

            

                1470
            

            

                
            

            

                
                                                                        if v2.0 == v136.0 {

            

        

            

                1471
            

            

                
            

            

                
                                                                            let v296 = constructor_band(ctx, v2.0, v125.1, v7.1);

            

        

            

                1472
            

            

                
            

            

                
                                                                            let v297 = constructor_band(ctx, v2.0, v125.0, v296);

            

        

            

                1473
            

            

                
            

            

                
                                                                            // Rule at src/opts/cprop.isle line 162.

            

        

            

                1474
            

            

                
            

            

                
                                                                            returns.push(v297);

            

        

            

                1475
            

            

                
            

            

                
                                                                        }

            

        

            

                1476
            

            

                
            

            

                
                                                                    }

            

        

            

                1477
            

            

                
            

            

                
                                                                }

            

        

            

                1478
            

            

                
            

            

                
                                                            }

            

        

            

                1479
            

            

                
            

            

                
                                                        }

            

        

            

                1480
            

            

                
            

            

                
                                                    }

            

        

            

                1481
            

            

                
            

            

                
                                                }

            

        

            

                1482
            

            

                
            

            

                
                                            }

            

        

            

                1483
            

            

                
            

            

                
                                        }

            

        

            

                1484
            

            

                
            

            

                
                                    }

            

        

            

                1485
            

            

                
            

            

                
                                }

            

        

            

                1486
            

            

                
            

            

                
                                &InstructionData::IntCompare {

            

        

            

                1487
            

            

                
            

            

                
                                    opcode: ref v374,

            

        

            

                1488
            

            

                
            

            

                
                                    args: ref v375,

            

        

            

                1489
            

            

                
            

            

                
                                    cond: ref v376,

            

        

            

                1490
            

            

                
            

            

                
                                } => {

            

        

            

                1491
            

            

                
            

            

                
                                    if let &Opcode::Icmp = v374 {

            

        

            

                1492
            

            

                
            

            

                
                                        let v10 = C::inst_data_etor(ctx, v7.1);

            

        

            

                1493
            

            

                
            

            

                
                                        let mut v10 = v10;

            

        

            

                1494
            

            

                
            

            

                
                                        while let Some(v11) = v10.next(ctx) {

            

        

            

                1495
            

            

                
            

            

                
                                            match &v11.1 {

            

        

            

                1496
            

            

                
            

            

                
                                                &InstructionData::IntCompare {

            

        

            

                1497
            

            

                
            

            

                
                                                    opcode: ref v399,

            

        

            

                1498
            

            

                
            

            

                
                                                    args: ref v400,

            

        

            

                1499
            

            

                
            

            

                
                                                    cond: ref v401,

            

        

            

                1500
            

            

                
            

            

                
                                                } => {

            

        

            

                1501
            

            

                
            

            

                
                                                    if let &Opcode::Icmp = v399 {

            

        

            

                1502
            

            

                
            

            

                
                                                        let v44 = C::fits_in_64(ctx, v2.0);

            

        

            

                1503
            

            

                
            

            

                
                                                        if let Some(v45) = v44 {

            

        

            

                1504
            

            

                
            

            

                
                                                            let v405 = constructor_intcc_comparable(

            

        

            

                1505
            

            

                
            

            

                
                                                                ctx, v376, v401,

            

        

            

                1506
            

            

                
            

            

                
                                                            );

            

        

            

                1507
            

            

                
            

            

                
                                                            if let Some(v406) = v405 {

            

        

            

                1508
            

            

                
            

            

                
                                                                if v11.0 == v19.0 {

            

        

            

                1509
            

            

                
            

            

                
                                                                    if v11.0 == v45 {

            

        

            

                1510
            

            

                
            

            

                
                                                                        let v377 =

            

        

            

                1511
            

            

                
            

            

                
                                                                            C::unpack_value_array_2(

            

        

            

                1512
            

            

                
            

            

                
                                                                                ctx, v375,

            

        

            

                1513
            

            

                
            

            

                
                                                                            );

            

        

            

                1514
            

            

                
            

            

                
                                                                        let v402 =

            

        

            

                1515
            

            

                
            

            

                
                                                                            C::unpack_value_array_2(

            

        

            

                1516
            

            

                
            

            

                
                                                                                ctx, v400,

            

        

            

                1517
            

            

                
            

            

                
                                                                            );

            

        

            

                1518
            

            

                
            

            

                
                                                                        if v377.0 == v402.0 {

            

        

            

                1519
            

            

                
            

            

                
                                                                            if v377.1 == v402.1 {

            

        

            

                1520
            

            

                
            

            

                
                                                                                let v407 = constructor_decompose_intcc(ctx, v376);

            

        

            

                1521
            

            

                
            

            

                
                                                                                let v408 = constructor_decompose_intcc(ctx, v401);

            

        

            

                1522
            

            

                
            

            

                
                                                                                let v409 =

            

        

            

                1523
            

            

                
            

            

                
                                                                                    C::u64_and(

            

        

            

                1524
            

            

                
            

            

                
                                                                                        ctx, v407,

            

        

            

                1525
            

            

                
            

            

                
                                                                                        v408,

            

        

            

                1526
            

            

                
            

            

                
                                                                                    );

            

        

            

                1527
            

            

                
            

            

                
                                                                                let v410 = constructor_compose_icmp(ctx, v45, v409, v406, v377.0, v377.1);

            

        

            

                1528
            

            

                
            

            

                
                                                                                // Rule at src/opts/icmp.isle line 128.

            

        

            

                1529
            

            

                
            

            

                
                                                                                returns.push(v410);

            

        

            

                1530
            

            

                
            

            

                
                                                                            }

            

        

            

                1531
            

            

                
            

            

                
                                                                        }

            

        

            

                1532
            

            

                
            

            

                
                                                                    }

            

        

            

                1533
            

            

                
            

            

                
                                                                }

            

        

            

                1534
            

            

                
            

            

                
                                                            }

            

        

            

                1535
            

            

                
            

            

                
                                                        }

            

        

            

                1536
            

            

                
            

            

                
                                                    }

            

        

            

                1537
            

            

                
            

            

                
                                                }

            

        

            

                1538
            

            

                
            

            

                
                                                &InstructionData::UnaryImm {

            

        

            

                1539
            

            

                
            

            

                
                                                    opcode: ref v14,

            

        

            

                1540
            

            

                
            

            

                
                                                    imm: v15,

            

        

            

                1541
            

            

                
            

            

                
                                                } => {

            

        

            

                1542
            

            

                
            

            

                
                                                    if let &Opcode::Iconst = v14 {

            

        

            

                1543
            

            

                
            

            

                
                                                        let v16 = C::u64_from_imm64(ctx, v15);

            

        

            

                1544
            

            

                
            

            

                
                                                        if v16 == 0x1 {

            

        

            

                1545
            

            

                
            

            

                
                                                            let v372 = C::ty_int(ctx, v2.0);

            

        

            

                1546
            

            

                
            

            

                
                                                            if let Some(v373) = v372 {

            

        

            

                1547
            

            

                
            

            

                
                                                                // Rule at src/opts/icmp.isle line 39.

            

        

            

                1548
            

            

                
            

            

                
                                                                returns.push(v7.0);

            

        

            

                1549
            

            

                
            

            

                
                                                            }

            

        

            

                1550
            

            

                
            

            

                
                                                        }

            

        

            

                1551
            

            

                
            

            

                
                                                    }

            

        

            

                1552
            

            

                
            

            

                
                                                }

            

        

            

                1553
            

            

                
            

            

                
                                                _ => {}

            

        

            

                1554
            

            

                
            

            

                
                                            }

            

        

            

                1555
            

            

                
            

            

                
                                        }

            

        

            

                1556
            

            

                
            

            

                
                                    }

            

        

            

                1557
            

            

                
            

            

                
                                }

            

        

            

                1558
            

            

                
            

            

                
                                &InstructionData::Unary {

            

        

            

                1559
            

            

                
            

            

                
                                    opcode: ref v36,

            

        

            

                1560
            

            

                
            

            

                
                                    arg: v37,

            

        

            

                1561
            

            

                
            

            

                
                                } => {

            

        

            

                1562
            

            

                
            

            

                
                                    match v36 {

            

        

            

                1563
            

            

                
            

            

                
                                        &Opcode::Splat => {

            

        

            

                1564
            

            

                
            

            

                
                                            let v486 = C::ty_vector_not_float(ctx, v2.0);

            

        

            

                1565
            

            

                
            

            

                
                                            if let Some(v487) = v486 {

            

        

            

                1566
            

            

                
            

            

                
                                                if v2.0 == v19.0 {

            

        

            

                1567
            

            

                
            

            

                
                                                    let v10 = C::inst_data_etor(ctx, v7.1);

            

        

            

                1568
            

            

                
            

            

                
                                                    let mut v10 = v10;

            

        

            

                1569
            

            

                
            

            

                
                                                    while let Some(v11) = v10.next(ctx) {

            

        

            

                1570
            

            

                
            

            

                
                                                        if let &InstructionData::Unary {

            

        

            

                1571
            

            

                
            

            

                
                                                            opcode: ref v38,

            

        

            

                1572
            

            

                
            

            

                
                                                            arg: v39,

            

        

            

                1573
            

            

                
            

            

                
                                                        } = &v11.1

            

        

            

                1574
            

            

                
            

            

                
                                                        {

            

        

            

                1575
            

            

                
            

            

                
                                                            if let &Opcode::Splat = v38 {

            

        

            

                1576
            

            

                
            

            

                
                                                                if v2.0 == v11.0 {

            

        

            

                1577
            

            

                
            

            

                
                                                                    let v481 =

            

        

            

                1578
            

            

                
            

            

                
                                                                        C::lane_type(ctx, v2.0);

            

        

            

                1579
            

            

                
            

            

                
                                                                    let v488 = constructor_band(

            

        

            

                1580
            

            

                
            

            

                
                                                                        ctx, v481, v37, v39,

            

        

            

                1581
            

            

                
            

            

                
                                                                    );

            

        

            

                1582
            

            

                
            

            

                
                                                                    let v489 = constructor_splat(

            

        

            

                1583
            

            

                
            

            

                
                                                                        ctx, v2.0, v488,

            

        

            

                1584
            

            

                
            

            

                
                                                                    );

            

        

            

                1585
            

            

                
            

            

                
                                                                    // Rule at src/opts/vector.isle line 14.

            

        

            

                1586
            

            

                
            

            

                
                                                                    returns.push(v489);

            

        

            

                1587
            

            

                
            

            

                
                                                                }

            

        

            

                1588
            

            

                
            

            

                
                                                            }

            

        

            

                1589
            

            

                
            

            

                
                                                        }

            

        

            

                1590
            

            

                
            

            

                
                                                    }

            

        

            

                1591
            

            

                
            

            

                
                                                }

            

        

            

                1592
            

            

                
            

            

                
                                            }

            

        

            

                1593
            

            

                
            

            

                
                                        }

            

        

            

                1594
            

            

                
            

            

                
                                        &Opcode::Bnot => {

            

        

            

                1595
            

            

                
            

            

                
                                            let v44 = C::fits_in_64(ctx, v2.0);

            

        

            

                1596
            

            

                
            

            

                
                                            if let Some(v45) = v44 {

            

        

            

                1597
            

            

                
            

            

                
                                                let v46 = C::ty_int(ctx, v45);

            

        

            

                1598
            

            

                
            

            

                
                                                if let Some(v47) = v46 {

            

        

            

                1599
            

            

                
            

            

                
                                                    if v7.1 == v37 {

            

        

            

                1600
            

            

                
            

            

                
                                                        if v19.0 == v47 {

            

        

            

                1601
            

            

                
            

            

                
                                                            let v49 = C::imm64(ctx, 0x0);

            

        

            

                1602
            

            

                
            

            

                
                                                            let v50 =

            

        

            

                1603
            

            

                
            

            

                
                                                                constructor_iconst(ctx, v47, v49);

            

        

            

                1604
            

            

                
            

            

                
                                                            let v51 = C::subsume(ctx, v50);

            

        

            

                1605
            

            

                
            

            

                
                                                            // Rule at src/opts/bitops.isle line 50.

            

        

            

                1606
            

            

                
            

            

                
                                                            returns.push(v51);

            

        

            

                1607
            

            

                
            

            

                
                                                        }

            

        

            

                1608
            

            

                
            

            

                
                                                    }

            

        

            

                1609
            

            

                
            

            

                
                                                }

            

        

            

                1610
            

            

                
            

            

                
                                            }

            

        

            

                1611
            

            

                
            

            

                
                                        }

            

        

            

                1612
            

            

                
            

            

                
                                        &Opcode::Uextend => {

            

        

            

                1613
            

            

                
            

            

                
                                            let v10 = C::inst_data_etor(ctx, v7.1);

            

        

            

                1614
            

            

                
            

            

                
                                            let mut v10 = v10;

            

        

            

                1615
            

            

                
            

            

                
                                            while let Some(v11) = v10.next(ctx) {

            

        

            

                1616
            

            

                
            

            

                
                                                if let &InstructionData::UnaryImm {

            

        

            

                1617
            

            

                
            

            

                
                                                    opcode: ref v14,

            

        

            

                1618
            

            

                
            

            

                
                                                    imm: v15,

            

        

            

                1619
            

            

                
            

            

                
                                                } = &v11.1

            

        

            

                1620
            

            

                
            

            

                
                                                {

            

        

            

                1621
            

            

                
            

            

                
                                                    if let &Opcode::Iconst = v14 {

            

        

            

                1622
            

            

                
            

            

                
                                                        let v16 = C::u64_from_imm64(ctx, v15);

            

        

            

                1623
            

            

                
            

            

                
                                                        if v16 == 0x1 {

            

        

            

                1624
            

            

                
            

            

                
                                                            let v372 = C::ty_int(ctx, v2.0);

            

        

            

                1625
            

            

                
            

            

                
                                                            if let Some(v373) = v372 {

            

        

            

                1626
            

            

                
            

            

                
                                                                let v380 =

            

        

            

                1627
            

            

                
            

            

                
                                                                    C::inst_data_etor(ctx, v37);

            

        

            

                1628
            

            

                
            

            

                
                                                                let mut v380 = v380;

            

        

            

                1629
            

            

                
            

            

                
                                                                while let Some(v381) =

            

        

            

                1630
            

            

                
            

            

                
                                                                    v380.next(ctx)

            

        

            

                1631
            

            

                
            

            

                
                                                                {

            

        

            

                1632
            

            

                
            

            

                
                                                                    if let &InstructionData::IntCompare {

            

        

            

                1633
            

            

                
            

            

                
                                                                        opcode: ref v384,

            

        

            

                1634
            

            

                
            

            

                
                                                                        args: ref v385,

            

        

            

                1635
            

            

                
            

            

                
                                                                        cond: ref v386,

            

        

            

                1636
            

            

                
            

            

                
                                                                    } = &v381.1 {

            

        

            

                1637
            

            

                
            

            

                
                                                                        if let &Opcode::Icmp = v384 {

            

        

            

                1638
            

            

                
            

            

                
                                                                            // Rule at src/opts/icmp.isle line 44.

            

        

            

                1639
            

            

                
            

            

                
                                                                            returns.push(v7.0);

            

        

            

                1640
            

            

                
            

            

                
                                                                        }

            

        

            

                1641
            

            

                
            

            

                
                                                                    }

            

        

            

                1642
            

            

                
            

            

                
                                                                }

            

        

            

                1643
            

            

                
            

            

                
                                                            }

            

        

            

                1644
            

            

                
            

            

                
                                                        }

            

        

            

                1645
            

            

                
            

            

                
                                                        let v333 = C::value_type(ctx, v37);

            

        

            

                1646
            

            

                
            

            

                
                                                        let v334 = C::ty_mask(ctx, v333);

            

        

            

                1647
            

            

                
            

            

                
                                                        let v335 = C::u64_and(ctx, v16, v334);

            

        

            

                1648
            

            

                
            

            

                
                                                        let v336 = C::u64_eq(ctx, v334, v335);

            

        

            

                1649
            

            

                
            

            

                
                                                        if v336 == true {

            

        

            

                1650
            

            

                
            

            

                
                                                            // Rule at src/opts/extends.isle line 9.

            

        

            

                1651
            

            

                
            

            

                
                                                            returns.push(v7.0);

            

        

            

                1652
            

            

                
            

            

                
                                                        }

            

        

            

                1653
            

            

                
            

            

                
                                                    }

            

        

            

                1654
            

            

                
            

            

                
                                                }

            

        

            

                1655
            

            

                
            

            

                
                                            }

            

        

            

                1656
            

            

                
            

            

                
                                        }

            

        

            

                1657
            

            

                
            

            

                
                                        &Opcode::Sextend => {

            

        

            

                1658
            

            

                
            

            

                
                                            let v10 = C::inst_data_etor(ctx, v7.1);

            

        

            

                1659
            

            

                
            

            

                
                                            let mut v10 = v10;

            

        

            

                1660
            

            

                
            

            

                
                                            while let Some(v11) = v10.next(ctx) {

            

        

            

                1661
            

            

                
            

            

                
                                                if let &InstructionData::UnaryImm {

            

        

            

                1662
            

            

                
            

            

                
                                                    opcode: ref v14,

            

        

            

                1663
            

            

                
            

            

                
                                                    imm: v15,

            

        

            

                1664
            

            

                
            

            

                
                                                } = &v11.1

            

        

            

                1665
            

            

                
            

            

                
                                                {

            

        

            

                1666
            

            

                
            

            

                
                                                    if let &Opcode::Iconst = v14 {

            

        

            

                1667
            

            

                
            

            

                
                                                        let v16 = C::u64_from_imm64(ctx, v15);

            

        

            

                1668
            

            

                
            

            

                
                                                        let v333 = C::value_type(ctx, v37);

            

        

            

                1669
            

            

                
            

            

                
                                                        let v334 = C::ty_mask(ctx, v333);

            

        

            

                1670
            

            

                
            

            

                
                                                        let v337 = C::u64_eq(ctx, v16, v334);

            

        

            

                1671
            

            

                
            

            

                
                                                        if v337 == true {

            

        

            

                1672
            

            

                
            

            

                
                                                            let v338 =

            

        

            

                1673
            

            

                
            

            

                
                                                                constructor_uextend(ctx, v2.0, v37);

            

        

            

                1674
            

            

                
            

            

                
                                                            // Rule at src/opts/extends.isle line 15.

            

        

            

                1675
            

            

                
            

            

                
                                                            returns.push(v338);

            

        

            

                1676
            

            

                
            

            

                
                                                        }

            

        

            

                1677
            

            

                
            

            

                
                                                    }

            

        

            

                1678
            

            

                
            

            

                
                                                }

            

        

            

                1679
            

            

                
            

            

                
                                            }

            

        

            

                1680
            

            

                
            

            

                
                                        }

            

        

            

                1681
            

            

                
            

            

                
                                        _ => {}

            

        

            

                1682
            

            

                
            

            

                
                                    }

            

        

            

                1683
            

            

                
            

            

                
                                }

            

        

            

                1684
            

            

                
            

            

                
                                &InstructionData::UnaryImm {

            

        

            

                1685
            

            

                
            

            

                
                                    opcode: ref v22,

            

        

            

                1686
            

            

                
            

            

                
                                    imm: v23,

            

        

            

                1687
            

            

                
            

            

                
                                } => {

            

        

            

                1688
            

            

                
            

            

                
                                    if let &Opcode::Iconst = v22 {

            

        

            

                1689
            

            

                
            

            

                
                                        if v2.0 == v19.0 {

            

        

            

                1690
            

            

                
            

            

                
                                            let v24 = C::u64_from_imm64(ctx, v23);

            

        

            

                1691
            

            

                
            

            

                
                                            if v24 == 0x0 {

            

        

            

                1692
            

            

                
            

            

                
                                                let v17 = C::subsume(ctx, v7.0);

            

        

            

                1693
            

            

                
            

            

                
                                                // Rule at src/opts/bitops.isle line 48.

            

        

            

                1694
            

            

                
            

            

                
                                                returns.push(v17);

            

        

            

                1695
            

            

                
            

            

                
                                            }

            

        

            

                1696
            

            

                
            

            

                
                                            let v54 = C::i64_sextend_imm64(ctx, v2.0, v23);

            

        

            

                1697
            

            

                
            

            

                
                                            if v54 == -0x1 {

            

        

            

                1698
            

            

                
            

            

                
                                                let v25 = C::subsume(ctx, v7.1);

            

        

            

                1699
            

            

                
            

            

                
                                                // Rule at src/opts/bitops.isle line 42.

            

        

            

                1700
            

            

                
            

            

                
                                                returns.push(v25);

            

        

            

                1701
            

            

                
            

            

                
                                            }

            

        

            

                1702
            

            

                
            

            

                
                                            let v266 = constructor_band(ctx, v2.0, v7.1, v7.0);

            

        

            

                1703
            

            

                
            

            

                
                                            // Rule at src/opts/cprop.isle line 109.

            

        

            

                1704
            

            

                
            

            

                
                                            returns.push(v266);

            

        

            

                1705
            

            

                
            

            

                
                                        }

            

        

            

                1706
            

            

                
            

            

                
                                        let v44 = C::fits_in_64(ctx, v2.0);

            

        

            

                1707
            

            

                
            

            

                
                                        if let Some(v45) = v44 {

            

        

            

                1708
            

            

                
            

            

                
                                            if v19.0 == v45 {

            

        

            

                1709
            

            

                
            

            

                
                                                let v10 = C::inst_data_etor(ctx, v7.1);

            

        

            

                1710
            

            

                
            

            

                
                                                let mut v10 = v10;

            

        

            

                1711
            

            

                
            

            

                
                                                while let Some(v11) = v10.next(ctx) {

            

        

            

                1712
            

            

                
            

            

                
                                                    if let &InstructionData::UnaryImm {

            

        

            

                1713
            

            

                
            

            

                
                                                        opcode: ref v14,

            

        

            

                1714
            

            

                
            

            

                
                                                        imm: v15,

            

        

            

                1715
            

            

                
            

            

                
                                                    } = &v11.1

            

        

            

                1716
            

            

                
            

            

                
                                                    {

            

        

            

                1717
            

            

                
            

            

                
                                                        if let &Opcode::Iconst = v14 {

            

        

            

                1718
            

            

                
            

            

                
                                                            if v11.0 == v19.0 {

            

        

            

                1719
            

            

                
            

            

                
                                                                let v24 =

            

        

            

                1720
            

            

                
            

            

                
                                                                    C::u64_from_imm64(ctx, v23);

            

        

            

                1721
            

            

                
            

            

                
                                                                let v16 =

            

        

            

                1722
            

            

                
            

            

                
                                                                    C::u64_from_imm64(ctx, v15);

            

        

            

                1723
            

            

                
            

            

                
                                                                let v214 =

            

        

            

                1724
            

            

                
            

            

                
                                                                    C::u64_and(ctx, v24, v16);

            

        

            

                1725
            

            

                
            

            

                
                                                                let v215 =

            

        

            

                1726
            

            

                
            

            

                
                                                                    C::imm64_masked(ctx, v45, v214);

            

        

            

                1727
            

            

                
            

            

                
                                                                let v216 = constructor_iconst(

            

        

            

                1728
            

            

                
            

            

                
                                                                    ctx, v45, v215,

            

        

            

                1729
            

            

                
            

            

                
                                                                );

            

        

            

                1730
            

            

                
            

            

                
                                                                let v217 = C::subsume(ctx, v216);

            

        

            

                1731
            

            

                
            

            

                
                                                                // Rule at src/opts/cprop.isle line 41.

            

        

            

                1732
            

            

                
            

            

                
                                                                returns.push(v217);

            

        

            

                1733
            

            

                
            

            

                
                                                            }

            

        

            

                1734
            

            

                
            

            

                
                                                        }

            

        

            

                1735
            

            

                
            

            

                
                                                    }

            

        

            

                1736
            

            

                
            

            

                
                                                }

            

        

            

                1737
            

            

                
            

            

                
                                            }

            

        

            

                1738
            

            

                
            

            

                
                                        }

            

        

            

                1739
            

            

                
            

            

                
                                        let v413 = C::remat(ctx, arg0);

            

        

            

                1740
            

            

                
            

            

                
                                        // Rule at src/opts/remat.isle line 12.

            

        

            

                1741
            

            

                
            

            

                
                                        returns.push(v413);

            

        

            

                1742
            

            

                
            

            

                
                                    }

            

        

            

                1743
            

            

                
            

            

                
                                }

            

        

            

                1744
            

            

                
            

            

                
                                _ => {}

            

        

            

                1745
            

            

                
            

            

                
                            }

            

        

            

                1746
            

            

                
            

            

                
                        }

            

        

            

                1747
            

            

                
            

            

                
                        let v10 = C::inst_data_etor(ctx, v7.1);

            

        

            

                1748
            

            

                
            

            

                
                        let mut v10 = v10;

            

        

            

                1749
            

            

                
            

            

                
                        while let Some(v11) = v10.next(ctx) {

            

        

            

                1750
            

            

                
            

            

                
                            match &v11.1 {

            

        

            

                1751
            

            

                
            

            

                
                                &InstructionData::Unary {

            

        

            

                1752
            

            

                
            

            

                
                                    opcode: ref v38,

            

        

            

                1753
            

            

                
            

            

                
                                    arg: v39,

            

        

            

                1754
            

            

                
            

            

                
                                } => {

            

        

            

                1755
            

            

                
            

            

                
                                    if let &Opcode::Bnot = v38 {

            

        

            

                1756
            

            

                
            

            

                
                                        if v7.0 == v39 {

            

        

            

                1757
            

            

                
            

            

                
                                            let v44 = C::fits_in_64(ctx, v2.0);

            

        

            

                1758
            

            

                
            

            

                
                                            if let Some(v45) = v44 {

            

        

            

                1759
            

            

                
            

            

                
                                                let v46 = C::ty_int(ctx, v45);

            

        

            

                1760
            

            

                
            

            

                
                                                if let Some(v47) = v46 {

            

        

            

                1761
            

            

                
            

            

                
                                                    if v11.0 == v47 {

            

        

            

                1762
            

            

                
            

            

                
                                                        let v49 = C::imm64(ctx, 0x0);

            

        

            

                1763
            

            

                
            

            

                
                                                        let v50 = constructor_iconst(ctx, v47, v49);

            

        

            

                1764
            

            

                
            

            

                
                                                        let v51 = C::subsume(ctx, v50);

            

        

            

                1765
            

            

                
            

            

                
                                                        // Rule at src/opts/bitops.isle line 49.

            

        

            

                1766
            

            

                
            

            

                
                                                        returns.push(v51);

            

        

            

                1767
            

            

                
            

            

                
                                                    }

            

        

            

                1768
            

            

                
            

            

                
                                                }

            

        

            

                1769
            

            

                
            

            

                
                                            }

            

        

            

                1770
            

            

                
            

            

                
                                        }

            

        

            

                1771
            

            

                
            

            

                
                                    }

            

        

            

                1772
            

            

                
            

            

                
                                }

            

        

            

                1773
            

            

                
            

            

                
                                &InstructionData::UnaryImm {

            

        

            

                1774
            

            

                
            

            

                
                                    opcode: ref v14,

            

        

            

                1775
            

            

                
            

            

                
                                    imm: v15,

            

        

            

                1776
            

            

                
            

            

                
                                } => {

            

        

            

                1777
            

            

                
            

            

                
                                    if let &Opcode::Iconst = v14 {

            

        

            

                1778
            

            

                
            

            

                
                                        if v2.0 == v11.0 {

            

        

            

                1779
            

            

                
            

            

                
                                            let v16 = C::u64_from_imm64(ctx, v15);

            

        

            

                1780
            

            

                
            

            

                
                                            if v16 == 0x0 {

            

        

            

                1781
            

            

                
            

            

                
                                                let v25 = C::subsume(ctx, v7.1);

            

        

            

                1782
            

            

                
            

            

                
                                                // Rule at src/opts/bitops.isle line 47.

            

        

            

                1783
            

            

                
            

            

                
                                                returns.push(v25);

            

        

            

                1784
            

            

                
            

            

                
                                            }

            

        

            

                1785
            

            

                
            

            

                
                                            let v52 = C::i64_sextend_imm64(ctx, v2.0, v15);

            

        

            

                1786
            

            

                
            

            

                
                                            if v52 == -0x1 {

            

        

            

                1787
            

            

                
            

            

                
                                                let v17 = C::subsume(ctx, v7.0);

            

        

            

                1788
            

            

                
            

            

                
                                                // Rule at src/opts/bitops.isle line 39.

            

        

            

                1789
            

            

                
            

            

                
                                                returns.push(v17);

            

        

            

                1790
            

            

                
            

            

                
                                            }

            

        

            

                1791
            

            

                
            

            

                
                                        }

            

        

            

                1792
            

            

                
            

            

                
                                        let v413 = C::remat(ctx, arg0);

            

        

            

                1793
            

            

                
            

            

                
                                        // Rule at src/opts/remat.isle line 14.

            

        

            

                1794
            

            

                
            

            

                
                                        returns.push(v413);

            

        

            

                1795
            

            

                
            

            

                
                                    }

            

        

            

                1796
            

            

                
            

            

                
                                }

            

        

            

                1797
            

            

                
            

            

                
                                _ => {}

            

        

            

                1798
            

            

                
            

            

                
                            }

            

        

            

                1799
            

            

                
            

            

                
                        }

            

        

            

                1800
            

            

                
            

            

                
                        if v7.0 == v7.1 {

            

        

            

                1801
            

            

                
            

            

                
                            let v17 = C::subsume(ctx, v7.0);

            

        

            

                1802
            

            

                
            

            

                
                            // Rule at src/opts/bitops.isle line 38.

            

        

            

                1803
            

            

                
            

            

                
                            returns.push(v17);

            

        

            

                1804
            

            

                
            

            

                
                        }

            

        

            

                1805
            

            

                
            

            

                
                    }

            

        

            

                1806
            

            

                
            

            

                
                    &Opcode::Bor => {

            

        

            

                1807
            

            

                
            

            

                
                        let v7 = C::unpack_value_array_2(ctx, v6);

            

        

            

                1808
            

            

                
            

            

                
                        let v18 = C::inst_data_etor(ctx, v7.0);

            

        

            

                1809
            

            

                
            

            

                
                        let mut v18 = v18;

            

        

            

                1810
            

            

                
            

            

                
                        while let Some(v19) = v18.next(ctx) {

            

        

            

                1811
            

            

                
            

            

                
                            match &v19.1 {

            

        

            

                1812
            

            

                
            

            

                
                                &InstructionData::Binary {

            

        

            

                1813
            

            

                
            

            

                
                                    opcode: ref v123,

            

        

            

                1814
            

            

                
            

            

                
                                    args: ref v124,

            

        

            

                1815
            

            

                
            

            

                
                                } => {

            

        

            

                1816
            

            

                
            

            

                
                                    match v123 {

            

        

            

                1817
            

            

                
            

            

                
                                        &Opcode::Band => {

            

        

            

                1818
            

            

                
            

            

                
                                            let v10 = C::inst_data_etor(ctx, v7.1);

            

        

            

                1819
            

            

                
            

            

                
                                            let mut v10 = v10;

            

        

            

                1820
            

            

                
            

            

                
                                            while let Some(v11) = v10.next(ctx) {

            

        

            

                1821
            

            

                
            

            

                
                                                match &v11.1 {

            

        

            

                1822
            

            

                
            

            

                
                                                    &InstructionData::Binary {

            

        

            

                1823
            

            

                
            

            

                
                                                        opcode: ref v129,

            

        

            

                1824
            

            

                
            

            

                
                                                        args: ref v130,

            

        

            

                1825
            

            

                
            

            

                
                                                    } => {

            

        

            

                1826
            

            

                
            

            

                
                                                        if let &Opcode::Band = v129 {

            

        

            

                1827
            

            

                
            

            

                
                                                            let v434 = C::ty_vec128(ctx, v2.0);

            

        

            

                1828
            

            

                
            

            

                
                                                            if let Some(v435) = v434 {

            

        

            

                1829
            

            

                
            

            

                
                                                                if v11.0 == v19.0 {

            

        

            

                1830
            

            

                
            

            

                
                                                                    if v11.0 == v435 {

            

        

            

                1831
            

            

                
            

            

                
                                                                        let v125 =

            

        

            

                1832
            

            

                
            

            

                
                                                                            C::unpack_value_array_2(

            

        

            

                1833
            

            

                
            

            

                
                                                                                ctx, v124,

            

        

            

                1834
            

            

                
            

            

                
                                                                            );

            

        

            

                1835
            

            

                
            

            

                
                                                                        let v135 =

            

        

            

                1836
            

            

                
            

            

                
                                                                            C::inst_data_etor(

            

        

            

                1837
            

            

                
            

            

                
                                                                                ctx, v125.1,

            

        

            

                1838
            

            

                
            

            

                
                                                                            );

            

        

            

                1839
            

            

                
            

            

                
                                                                        let mut v135 = v135;

            

        

            

                1840
            

            

                
            

            

                
                                                                        while let Some(v136) =

            

        

            

                1841
            

            

                
            

            

                
                                                                            v135.next(ctx)

            

        

            

                1842
            

            

                
            

            

                
                                                                        {

            

        

            

                1843
            

            

                
            

            

                
                                                                            if let &InstructionData::Unary {

            

        

            

                1844
            

            

                
            

            

                
                                                                                opcode: ref v148,

            

        

            

                1845
            

            

                
            

            

                
                                                                                arg: v149,

            

        

            

                1846
            

            

                
            

            

                
                                                                            } = &v136.1 {

            

        

            

                1847
            

            

                
            

            

                
                                                                                if let &Opcode::Bnot = v148 {

            

        

            

                1848
            

            

                
            

            

                
                                                                                    if v11.0 == v136.0 {

            

        

            

                1849
            

            

                
            

            

                
                                                                                        let v131 = C::unpack_value_array_2(ctx, v130);

            

        

            

                1850
            

            

                
            

            

                
                                                                                        if v131.0 == v149 {

            

        

            

                1851
            

            

                
            

            

                
                                                                                            let v454 = constructor_bitselect(ctx, v435, v149, v131.1, v125.0);

            

        

            

                1852
            

            

                
            

            

                
                                                                                            // Rule at src/opts/selects.isle line 58.

            

        

            

                1853
            

            

                
            

            

                
                                                                                            returns.push(v454);

            

        

            

                1854
            

            

                
            

            

                
                                                                                        }

            

        

            

                1855
            

            

                
            

            

                
                                                                                        if v131.1 == v149 {

            

        

            

                1856
            

            

                
            

            

                
                                                                                            let v455 = constructor_bitselect(ctx, v435, v149, v131.0, v125.0);

            

        

            

                1857
            

            

                
            

            

                
                                                                                            // Rule at src/opts/selects.isle line 59.

            

        

            

                1858
            

            

                
            

            

                
                                                                                            returns.push(v455);

            

        

            

                1859
            

            

                
            

            

                
                                                                                        }

            

        

            

                1860
            

            

                
            

            

                
                                                                                    }

            

        

            

                1861
            

            

                
            

            

                
                                                                                }

            

        

            

                1862
            

            

                
            

            

                
                                                                            }

            

        

            

                1863
            

            

                
            

            

                
                                                                        }

            

        

            

                1864
            

            

                
            

            

                
                                                                        let v156 =

            

        

            

                1865
            

            

                
            

            

                
                                                                            C::inst_data_etor(

            

        

            

                1866
            

            

                
            

            

                
                                                                                ctx, v125.0,

            

        

            

                1867
            

            

                
            

            

                
                                                                            );

            

        

            

                1868
            

            

                
            

            

                
                                                                        let mut v156 = v156;

            

        

            

                1869
            

            

                
            

            

                
                                                                        while let Some(v157) =

            

        

            

                1870
            

            

                
            

            

                
                                                                            v156.next(ctx)

            

        

            

                1871
            

            

                
            

            

                
                                                                        {

            

        

            

                1872
            

            

                
            

            

                
                                                                            if let &InstructionData::Unary {

            

        

            

                1873
            

            

                
            

            

                
                                                                                opcode: ref v160,

            

        

            

                1874
            

            

                
            

            

                
                                                                                arg: v161,

            

        

            

                1875
            

            

                
            

            

                
                                                                            } = &v157.1 {

            

        

            

                1876
            

            

                
            

            

                
                                                                                if let &Opcode::Bnot = v160 {

            

        

            

                1877
            

            

                
            

            

                
                                                                                    if v11.0 == v157.0 {

            

        

            

                1878
            

            

                
            

            

                
                                                                                        let v131 = C::unpack_value_array_2(ctx, v130);

            

        

            

                1879
            

            

                
            

            

                
                                                                                        if v131.0 == v161 {

            

        

            

                1880
            

            

                
            

            

                
                                                                                            let v452 = constructor_bitselect(ctx, v435, v161, v131.1, v125.1);

            

        

            

                1881
            

            

                
            

            

                
                                                                                            // Rule at src/opts/selects.isle line 56.

            

        

            

                1882
            

            

                
            

            

                
                                                                                            returns.push(v452);

            

        

            

                1883
            

            

                
            

            

                
                                                                                        }

            

        

            

                1884
            

            

                
            

            

                
                                                                                        if v131.1 == v161 {

            

        

            

                1885
            

            

                
            

            

                
                                                                                            let v453 = constructor_bitselect(ctx, v435, v161, v131.0, v125.1);

            

        

            

                1886
            

            

                
            

            

                
                                                                                            // Rule at src/opts/selects.isle line 57.

            

        

            

                1887
            

            

                
            

            

                
                                                                                            returns.push(v453);

            

        

            

                1888
            

            

                
            

            

                
                                                                                        }

            

        

            

                1889
            

            

                
            

            

                
                                                                                    }

            

        

            

                1890
            

            

                
            

            

                
                                                                                }

            

        

            

                1891
            

            

                
            

            

                
                                                                            }

            

        

            

                1892
            

            

                
            

            

                
                                                                        }

            

        

            

                1893
            

            

                
            

            

                
                                                                        let v131 =

            

        

            

                1894
            

            

                
            

            

                
                                                                            C::unpack_value_array_2(

            

        

            

                1895
            

            

                
            

            

                
                                                                                ctx, v130,

            

        

            

                1896
            

            

                
            

            

                
                                                                            );

            

        

            

                1897
            

            

                
            

            

                
                                                                        let v436 =

            

        

            

                1898
            

            

                
            

            

                
                                                                            C::inst_data_etor(

            

        

            

                1899
            

            

                
            

            

                
                                                                                ctx, v131.0,

            

        

            

                1900
            

            

                
            

            

                
                                                                            );

            

        

            

                1901
            

            

                
            

            

                
                                                                        let mut v436 = v436;

            

        

            

                1902
            

            

                
            

            

                
                                                                        while let Some(v437) =

            

        

            

                1903
            

            

                
            

            

                
                                                                            v436.next(ctx)

            

        

            

                1904
            

            

                
            

            

                
                                                                        {

            

        

            

                1905
            

            

                
            

            

                
                                                                            if let &InstructionData::Unary {

            

        

            

                1906
            

            

                
            

            

                
                                                                                opcode: ref v440,

            

        

            

                1907
            

            

                
            

            

                
                                                                                arg: v441,

            

        

            

                1908
            

            

                
            

            

                
                                                                            } = &v437.1 {

            

        

            

                1909
            

            

                
            

            

                
                                                                                if let &Opcode::Bnot = v440 {

            

        

            

                1910
            

            

                
            

            

                
                                                                                    if v11.0 == v437.0 {

            

        

            

                1911
            

            

                
            

            

                
                                                                                        if v125.0 == v441 {

            

        

            

                1912
            

            

                
            

            

                
                                                                                            let v442 = constructor_bitselect(ctx, v435, v125.0, v125.1, v131.1);

            

        

            

                1913
            

            

                
            

            

                
                                                                                            // Rule at src/opts/selects.isle line 52.

            

        

            

                1914
            

            

                
            

            

                
                                                                                            returns.push(v442);

            

        

            

                1915
            

            

                
            

            

                
                                                                                        }

            

        

            

                1916
            

            

                
            

            

                
                                                                                        if v125.1 == v441 {

            

        

            

                1917
            

            

                
            

            

                
                                                                                            let v450 = constructor_bitselect(ctx, v435, v125.1, v125.0, v131.1);

            

        

            

                1918
            

            

                
            

            

                
                                                                                            // Rule at src/opts/selects.isle line 54.

            

        

            

                1919
            

            

                
            

            

                
                                                                                            returns.push(v450);

            

        

            

                1920
            

            

                
            

            

                
                                                                                        }

            

        

            

                1921
            

            

                
            

            

                
                                                                                    }

            

        

            

                1922
            

            

                
            

            

                
                                                                                }

            

        

            

                1923
            

            

                
            

            

                
                                                                            }

            

        

            

                1924
            

            

                
            

            

                
                                                                        }

            

        

            

                1925
            

            

                
            

            

                
                                                                        let v443 =

            

        

            

                1926
            

            

                
            

            

                
                                                                            C::inst_data_etor(

            

        

            

                1927
            

            

                
            

            

                
                                                                                ctx, v131.1,

            

        

            

                1928
            

            

                
            

            

                
                                                                            );

            

        

            

                1929
            

            

                
            

            

                
                                                                        let mut v443 = v443;

            

        

            

                1930
            

            

                
            

            

                
                                                                        while let Some(v444) =

            

        

            

                1931
            

            

                
            

            

                
                                                                            v443.next(ctx)

            

        

            

                1932
            

            

                
            

            

                
                                                                        {

            

        

            

                1933
            

            

                
            

            

                
                                                                            if let &InstructionData::Unary {

            

        

            

                1934
            

            

                
            

            

                
                                                                                opcode: ref v447,

            

        

            

                1935
            

            

                
            

            

                
                                                                                arg: v448,

            

        

            

                1936
            

            

                
            

            

                
                                                                            } = &v444.1 {

            

        

            

                1937
            

            

                
            

            

                
                                                                                if let &Opcode::Bnot = v447 {

            

        

            

                1938
            

            

                
            

            

                
                                                                                    if v11.0 == v444.0 {

            

        

            

                1939
            

            

                
            

            

                
                                                                                        if v125.0 == v448 {

            

        

            

                1940
            

            

                
            

            

                
                                                                                            let v449 = constructor_bitselect(ctx, v435, v125.0, v125.1, v131.0);

            

        

            

                1941
            

            

                
            

            

                
                                                                                            // Rule at src/opts/selects.isle line 53.

            

        

            

                1942
            

            

                
            

            

                
                                                                                            returns.push(v449);

            

        

            

                1943
            

            

                
            

            

                
                                                                                        }

            

        

            

                1944
            

            

                
            

            

                
                                                                                        if v125.1 == v448 {

            

        

            

                1945
            

            

                
            

            

                
                                                                                            let v451 = constructor_bitselect(ctx, v435, v125.1, v125.0, v131.0);

            

        

            

                1946
            

            

                
            

            

                
                                                                                            // Rule at src/opts/selects.isle line 55.

            

        

            

                1947
            

            

                
            

            

                
                                                                                            returns.push(v451);

            

        

            

                1948
            

            

                
            

            

                
                                                                                        }

            

        

            

                1949
            

            

                
            

            

                
                                                                                    }

            

        

            

                1950
            

            

                
            

            

                
                                                                                }

            

        

            

                1951
            

            

                
            

            

                
                                                                            }

            

        

            

                1952
            

            

                
            

            

                
                                                                        }

            

        

            

                1953
            

            

                
            

            

                
                                                                    }

            

        

            

                1954
            

            

                
            

            

                
                                                                }

            

        

            

                1955
            

            

                
            

            

                
                                                            }

            

        

            

                1956
            

            

                
            

            

                
                                                        }

            

        

            

                1957
            

            

                
            

            

                
                                                    }

            

        

            

                1958
            

            

                
            

            

                
                                                    &InstructionData::Unary {

            

        

            

                1959
            

            

                
            

            

                
                                                        opcode: ref v38,

            

        

            

                1960
            

            

                
            

            

                
                                                        arg: v39,

            

        

            

                1961
            

            

                
            

            

                
                                                    } => {

            

        

            

                1962
            

            

                
            

            

                
                                                        if let &Opcode::Bnot = v38 {

            

        

            

                1963
            

            

                
            

            

                
                                                            if v2.0 == v11.0 {

            

        

            

                1964
            

            

                
            

            

                
                                                                if v2.0 == v19.0 {

            

        

            

                1965
            

            

                
            

            

                
                                                                    let v125 =

            

        

            

                1966
            

            

                
            

            

                
                                                                        C::unpack_value_array_2(

            

        

            

                1967
            

            

                
            

            

                
                                                                            ctx, v124,

            

        

            

                1968
            

            

                
            

            

                
                                                                        );

            

        

            

                1969
            

            

                
            

            

                
                                                                    if v39 == v125.1 {

            

        

            

                1970
            

            

                
            

            

                
                                                                        let v128 = constructor_bor(

            

        

            

                1971
            

            

                
            

            

                
                                                                            ctx, v2.0, v125.0, v7.1,

            

        

            

                1972
            

            

                
            

            

                
                                                                        );

            

        

            

                1973
            

            

                
            

            

                
                                                                        // Rule at src/opts/bitops.isle line 64.

            

        

            

                1974
            

            

                
            

            

                
                                                                        returns.push(v128);

            

        

            

                1975
            

            

                
            

            

                
                                                                    }

            

        

            

                1976
            

            

                
            

            

                
                                                                }

            

        

            

                1977
            

            

                
            

            

                
                                                            }

            

        

            

                1978
            

            

                
            

            

                
                                                        }

            

        

            

                1979
            

            

                
            

            

                
                                                    }

            

        

            

                1980
            

            

                
            

            

                
                                                    &InstructionData::UnaryImm {

            

        

            

                1981
            

            

                
            

            

                
                                                        opcode: ref v14,

            

        

            

                1982
            

            

                
            

            

                
                                                        imm: v15,

            

        

            

                1983
            

            

                
            

            

                
                                                    } => {

            

        

            

                1984
            

            

                
            

            

                
                                                        if let &Opcode::Iconst = v14 {

            

        

            

                1985
            

            

                
            

            

                
                                                            if v2.0 == v11.0 {

            

        

            

                1986
            

            

                
            

            

                
                                                                if v2.0 == v19.0 {

            

        

            

                1987
            

            

                
            

            

                
                                                                    let v125 =

            

        

            

                1988
            

            

                
            

            

                
                                                                        C::unpack_value_array_2(

            

        

            

                1989
            

            

                
            

            

                
                                                                            ctx, v124,

            

        

            

                1990
            

            

                
            

            

                
                                                                        );

            

        

            

                1991
            

            

                
            

            

                
                                                                    let v135 = C::inst_data_etor(

            

        

            

                1992
            

            

                
            

            

                
                                                                        ctx, v125.1,

            

        

            

                1993
            

            

                
            

            

                
                                                                    );

            

        

            

                1994
            

            

                
            

            

                
                                                                    let mut v135 = v135;

            

        

            

                1995
            

            

                
            

            

                
                                                                    while let Some(v136) =

            

        

            

                1996
            

            

                
            

            

                
                                                                        v135.next(ctx)

            

        

            

                1997
            

            

                
            

            

                
                                                                    {

            

        

            

                1998
            

            

                
            

            

                
                                                                        if let &InstructionData::UnaryImm {

            

        

            

                1999
            

            

                
            

            

                
                                                                            opcode: ref v139,

            

        

            

                2000
            

            

                
            

            

                
                                                                            imm: v140,

            

        

            

                2001
            

            

                
            

            

                
                                                                        } = &v136.1 {

            

        

            

                2002
            

            

                
            

            

                
                                                                            if let &Opcode::Iconst = v139 {

            

        

            

                2003
            

            

                
            

            

                
                                                                                let v142 = C::ty_mask(ctx, v2.0);

            

        

            

                2004
            

            

                
            

            

                
                                                                                let v16 = C::u64_from_imm64(ctx, v15);

            

        

            

                2005
            

            

                
            

            

                
                                                                                let v143 = C::u64_and(ctx, v142, v16);

            

        

            

                2006
            

            

                
            

            

                
                                                                                let v141 = C::u64_from_imm64(ctx, v140);

            

        

            

                2007
            

            

                
            

            

                
                                                                                let v144 = C::u64_not(ctx, v141);

            

        

            

                2008
            

            

                
            

            

                
                                                                                let v145 = C::u64_and(ctx, v142, v144);

            

        

            

                2009
            

            

                
            

            

                
                                                                                let v146 = C::u64_eq(ctx, v143, v145);

            

        

            

                2010
            

            

                
            

            

                
                                                                                if v146 == true {

            

        

            

                2011
            

            

                
            

            

                
                                                                                    if v2.0 == v136.0 {

            

        

            

                2012
            

            

                
            

            

                
                                                                                        let v128 = constructor_bor(ctx, v2.0, v125.0, v7.1);

            

        

            

                2013
            

            

                
            

            

                
                                                                                        // Rule at src/opts/bitops.isle line 84.

            

        

            

                2014
            

            

                
            

            

                
                                                                                        returns.push(v128);

            

        

            

                2015
            

            

                
            

            

                
                                                                                    }

            

        

            

                2016
            

            

                
            

            

                
                                                                                }

            

        

            

                2017
            

            

                
            

            

                
                                                                            }

            

        

            

                2018
            

            

                
            

            

                
                                                                        }

            

        

            

                2019
            

            

                
            

            

                
                                                                    }

            

        

            

                2020
            

            

                
            

            

                
                                                                }

            

        

            

                2021
            

            

                
            

            

                
                                                            }

            

        

            

                2022
            

            

                
            

            

                
                                                        }

            

        

            

                2023
            

            

                
            

            

                
                                                    }

            

        

            

                2024
            

            

                
            

            

                
                                                    _ => {}

            

        

            

                2025
            

            

                
            

            

                
                                                }

            

        

            

                2026
            

            

                
            

            

                
                                            }

            

        

            

                2027
            

            

                
            

            

                
                                        }

            

        

            

                2028
            

            

                
            

            

                
                                        &Opcode::Bor => {

            

        

            

                2029
            

            

                
            

            

                
                                            if v2.0 == v19.0 {

            

        

            

                2030
            

            

                
            

            

                
                                                let v10 = C::inst_data_etor(ctx, v7.1);

            

        

            

                2031
            

            

                
            

            

                
                                                let mut v10 = v10;

            

        

            

                2032
            

            

                
            

            

                
                                                while let Some(v11) = v10.next(ctx) {

            

        

            

                2033
            

            

                
            

            

                
                                                    if let &InstructionData::UnaryImm {

            

        

            

                2034
            

            

                
            

            

                
                                                        opcode: ref v14,

            

        

            

                2035
            

            

                
            

            

                
                                                        imm: v15,

            

        

            

                2036
            

            

                
            

            

                
                                                    } = &v11.1

            

        

            

                2037
            

            

                
            

            

                
                                                    {

            

        

            

                2038
            

            

                
            

            

                
                                                        if let &Opcode::Iconst = v14 {

            

        

            

                2039
            

            

                
            

            

                
                                                            if v2.0 == v11.0 {

            

        

            

                2040
            

            

                
            

            

                
                                                                let v125 = C::unpack_value_array_2(

            

        

            

                2041
            

            

                
            

            

                
                                                                    ctx, v124,

            

        

            

                2042
            

            

                
            

            

                
                                                                );

            

        

            

                2043
            

            

                
            

            

                
                                                                let v135 =

            

        

            

                2044
            

            

                
            

            

                
                                                                    C::inst_data_etor(ctx, v125.1);

            

        

            

                2045
            

            

                
            

            

                
                                                                let mut v135 = v135;

            

        

            

                2046
            

            

                
            

            

                
                                                                while let Some(v136) =

            

        

            

                2047
            

            

                
            

            

                
                                                                    v135.next(ctx)

            

        

            

                2048
            

            

                
            

            

                
                                                                {

            

        

            

                2049
            

            

                
            

            

                
                                                                    if let &InstructionData::UnaryImm {

            

        

            

                2050
            

            

                
            

            

                
                                                                        opcode: ref v139,

            

        

            

                2051
            

            

                
            

            

                
                                                                        imm: v140,

            

        

            

                2052
            

            

                
            

            

                
                                                                    } = &v136.1 {

            

        

            

                2053
            

            

                
            

            

                
                                                                        if let &Opcode::Iconst = v139 {

            

        

            

                2054
            

            

                
            

            

                
                                                                            if v2.0 == v136.0 {

            

        

            

                2055
            

            

                
            

            

                
                                                                                let v294 = constructor_bor(ctx, v2.0, v125.1, v7.1);

            

        

            

                2056
            

            

                
            

            

                
                                                                                let v295 = constructor_bor(ctx, v2.0, v125.0, v294);

            

        

            

                2057
            

            

                
            

            

                
                                                                                // Rule at src/opts/cprop.isle line 159.

            

        

            

                2058
            

            

                
            

            

                
                                                                                returns.push(v295);

            

        

            

                2059
            

            

                
            

            

                
                                                                            }

            

        

            

                2060
            

            

                
            

            

                
                                                                        }

            

        

            

                2061
            

            

                
            

            

                
                                                                    }

            

        

            

                2062
            

            

                
            

            

                
                                                                }

            

        

            

                2063
            

            

                
            

            

                
                                                            }

            

        

            

                2064
            

            

                
            

            

                
                                                        }

            

        

            

                2065
            

            

                
            

            

                
                                                    }

            

        

            

                2066
            

            

                
            

            

                
                                                }

            

        

            

                2067
            

            

                
            

            

                
                                            }

            

        

            

                2068
            

            

                
            

            

                
                                        }

            

        

            

                2069
            

            

                
            

            

                
                                        _ => {}

            

        

            

                2070
            

            

                
            

            

                
                                    }

            

        

            

                2071
            

            

                
            

            

                
                                }

            

        

            

                2072
            

            

                
            

            

                
                                &InstructionData::IntCompare {

            

        

            

                2073
            

            

                
            

            

                
                                    opcode: ref v374,

            

        

            

                2074
            

            

                
            

            

                
                                    args: ref v375,

            

        

            

                2075
            

            

                
            

            

                
                                    cond: ref v376,

            

        

            

                2076
            

            

                
            

            

                
                                } => {

            

        

            

                2077
            

            

                
            

            

                
                                    if let &Opcode::Icmp = v374 {

            

        

            

                2078
            

            

                
            

            

                
                                        let v44 = C::fits_in_64(ctx, v2.0);

            

        

            

                2079
            

            

                
            

            

                
                                        if let Some(v45) = v44 {

            

        

            

                2080
            

            

                
            

            

                
                                            if v19.0 == v45 {

            

        

            

                2081
            

            

                
            

            

                
                                                let v10 = C::inst_data_etor(ctx, v7.1);

            

        

            

                2082
            

            

                
            

            

                
                                                let mut v10 = v10;

            

        

            

                2083
            

            

                
            

            

                
                                                while let Some(v11) = v10.next(ctx) {

            

        

            

                2084
            

            

                
            

            

                
                                                    if let &InstructionData::IntCompare {

            

        

            

                2085
            

            

                
            

            

                
                                                        opcode: ref v399,

            

        

            

                2086
            

            

                
            

            

                
                                                        args: ref v400,

            

        

            

                2087
            

            

                
            

            

                
                                                        cond: ref v401,

            

        

            

                2088
            

            

                
            

            

                
                                                    } = &v11.1

            

        

            

                2089
            

            

                
            

            

                
                                                    {

            

        

            

                2090
            

            

                
            

            

                
                                                        if let &Opcode::Icmp = v399 {

            

        

            

                2091
            

            

                
            

            

                
                                                            let v405 = constructor_intcc_comparable(

            

        

            

                2092
            

            

                
            

            

                
                                                                ctx, v376, v401,

            

        

            

                2093
            

            

                
            

            

                
                                                            );

            

        

            

                2094
            

            

                
            

            

                
                                                            if let Some(v406) = v405 {

            

        

            

                2095
            

            

                
            

            

                
                                                                if v11.0 == v19.0 {

            

        

            

                2096
            

            

                
            

            

                
                                                                    let v377 =

            

        

            

                2097
            

            

                
            

            

                
                                                                        C::unpack_value_array_2(

            

        

            

                2098
            

            

                
            

            

                
                                                                            ctx, v375,

            

        

            

                2099
            

            

                
            

            

                
                                                                        );

            

        

            

                2100
            

            

                
            

            

                
                                                                    let v402 =

            

        

            

                2101
            

            

                
            

            

                
                                                                        C::unpack_value_array_2(

            

        

            

                2102
            

            

                
            

            

                
                                                                            ctx, v400,

            

        

            

                2103
            

            

                
            

            

                
                                                                        );

            

        

            

                2104
            

            

                
            

            

                
                                                                    if v377.0 == v402.0 {

            

        

            

                2105
            

            

                
            

            

                
                                                                        if v377.1 == v402.1 {

            

        

            

                2106
            

            

                
            

            

                
                                                                            let v407 = constructor_decompose_intcc(ctx, v376);

            

        

            

                2107
            

            

                
            

            

                
                                                                            let v408 = constructor_decompose_intcc(ctx, v401);

            

        

            

                2108
            

            

                
            

            

                
                                                                            let v411 = C::u64_or(

            

        

            

                2109
            

            

                
            

            

                
                                                                                ctx, v407, v408,

            

        

            

                2110
            

            

                
            

            

                
                                                                            );

            

        

            

                2111
            

            

                
            

            

                
                                                                            let v412 = constructor_compose_icmp(ctx, v45, v411, v406, v377.0, v377.1);

            

        

            

                2112
            

            

                
            

            

                
                                                                            // Rule at src/opts/icmp.isle line 132.

            

        

            

                2113
            

            

                
            

            

                
                                                                            returns.push(v412);

            

        

            

                2114
            

            

                
            

            

                
                                                                        }

            

        

            

                2115
            

            

                
            

            

                
                                                                    }

            

        

            

                2116
            

            

                
            

            

                
                                                                }

            

        

            

                2117
            

            

                
            

            

                
                                                            }

            

        

            

                2118
            

            

                
            

            

                
                                                        }

            

        

            

                2119
            

            

                
            

            

                
                                                    }

            

        

            

                2120
            

            

                
            

            

                
                                                }

            

        

            

                2121
            

            

                
            

            

                
                                            }

            

        

            

                2122
            

            

                
            

            

                
                                        }

            

        

            

                2123
            

            

                
            

            

                
                                    }

            

        

            

                2124
            

            

                
            

            

                
                                }

            

        

            

                2125
            

            

                
            

            

                
                                &InstructionData::Unary {

            

        

            

                2126
            

            

                
            

            

                
                                    opcode: ref v36,

            

        

            

                2127
            

            

                
            

            

                
                                    arg: v37,

            

        

            

                2128
            

            

                
            

            

                
                                } => {

            

        

            

                2129
            

            

                
            

            

                
                                    match v36 {

            

        

            

                2130
            

            

                
            

            

                
                                        &Opcode::Splat => {

            

        

            

                2131
            

            

                
            

            

                
                                            let v486 = C::ty_vector_not_float(ctx, v2.0);

            

        

            

                2132
            

            

                
            

            

                
                                            if let Some(v487) = v486 {

            

        

            

                2133
            

            

                
            

            

                
                                                if v2.0 == v19.0 {

            

        

            

                2134
            

            

                
            

            

                
                                                    let v10 = C::inst_data_etor(ctx, v7.1);

            

        

            

                2135
            

            

                
            

            

                
                                                    let mut v10 = v10;

            

        

            

                2136
            

            

                
            

            

                
                                                    while let Some(v11) = v10.next(ctx) {

            

        

            

                2137
            

            

                
            

            

                
                                                        if let &InstructionData::Unary {

            

        

            

                2138
            

            

                
            

            

                
                                                            opcode: ref v38,

            

        

            

                2139
            

            

                
            

            

                
                                                            arg: v39,

            

        

            

                2140
            

            

                
            

            

                
                                                        } = &v11.1

            

        

            

                2141
            

            

                
            

            

                
                                                        {

            

        

            

                2142
            

            

                
            

            

                
                                                            if let &Opcode::Splat = v38 {

            

        

            

                2143
            

            

                
            

            

                
                                                                if v2.0 == v11.0 {

            

        

            

                2144
            

            

                
            

            

                
                                                                    let v481 =

            

        

            

                2145
            

            

                
            

            

                
                                                                        C::lane_type(ctx, v2.0);

            

        

            

                2146
            

            

                
            

            

                
                                                                    let v490 = constructor_bor(

            

        

            

                2147
            

            

                
            

            

                
                                                                        ctx, v481, v37, v39,

            

        

            

                2148
            

            

                
            

            

                
                                                                    );

            

        

            

                2149
            

            

                
            

            

                
                                                                    let v491 = constructor_splat(

            

        

            

                2150
            

            

                
            

            

                
                                                                        ctx, v2.0, v490,

            

        

            

                2151
            

            

                
            

            

                
                                                                    );

            

        

            

                2152
            

            

                
            

            

                
                                                                    // Rule at src/opts/vector.isle line 18.

            

        

            

                2153
            

            

                
            

            

                
                                                                    returns.push(v491);

            

        

            

                2154
            

            

                
            

            

                
                                                                }

            

        

            

                2155
            

            

                
            

            

                
                                                            }

            

        

            

                2156
            

            

                
            

            

                
                                                        }

            

        

            

                2157
            

            

                
            

            

                
                                                    }

            

        

            

                2158
            

            

                
            

            

                
                                                }

            

        

            

                2159
            

            

                
            

            

                
                                            }

            

        

            

                2160
            

            

                
            

            

                
                                        }

            

        

            

                2161
            

            

                
            

            

                
                                        &Opcode::Bnot => {

            

        

            

                2162
            

            

                
            

            

                
                                            let v44 = C::fits_in_64(ctx, v2.0);

            

        

            

                2163
            

            

                
            

            

                
                                            if let Some(v45) = v44 {

            

        

            

                2164
            

            

                
            

            

                
                                                let v46 = C::ty_int(ctx, v45);

            

        

            

                2165
            

            

                
            

            

                
                                                if let Some(v47) = v46 {

            

        

            

                2166
            

            

                
            

            

                
                                                    if v7.1 == v37 {

            

        

            

                2167
            

            

                
            

            

                
                                                        if v19.0 == v47 {

            

        

            

                2168
            

            

                
            

            

                
                                                            let v115 = C::ty_mask(ctx, v47);

            

        

            

                2169
            

            

                
            

            

                
                                                            let v116 = C::imm64(ctx, v115);

            

        

            

                2170
            

            

                
            

            

                
                                                            let v117 =

            

        

            

                2171
            

            

                
            

            

                
                                                                constructor_iconst(ctx, v47, v116);

            

        

            

                2172
            

            

                
            

            

                
                                                            let v118 = C::subsume(ctx, v117);

            

        

            

                2173
            

            

                
            

            

                
                                                            // Rule at src/opts/bitops.isle line 35.

            

        

            

                2174
            

            

                
            

            

                
                                                            returns.push(v118);

            

        

            

                2175
            

            

                
            

            

                
                                                        }

            

        

            

                2176
            

            

                
            

            

                
                                                    }

            

        

            

                2177
            

            

                
            

            

                
                                                }

            

        

            

                2178
            

            

                
            

            

                
                                            }

            

        

            

                2179
            

            

                
            

            

                
                                            if v2.0 == v19.0 {

            

        

            

                2180
            

            

                
            

            

                
                                                let v10 = C::inst_data_etor(ctx, v7.1);

            

        

            

                2181
            

            

                
            

            

                
                                                let mut v10 = v10;

            

        

            

                2182
            

            

                
            

            

                
                                                while let Some(v11) = v10.next(ctx) {

            

        

            

                2183
            

            

                
            

            

                
                                                    if let &InstructionData::Binary {

            

        

            

                2184
            

            

                
            

            

                
                                                        opcode: ref v129,

            

        

            

                2185
            

            

                
            

            

                
                                                        args: ref v130,

            

        

            

                2186
            

            

                
            

            

                
                                                    } = &v11.1

            

        

            

                2187
            

            

                
            

            

                
                                                    {

            

        

            

                2188
            

            

                
            

            

                
                                                        if let &Opcode::Band = v129 {

            

        

            

                2189
            

            

                
            

            

                
                                                            if v2.0 == v11.0 {

            

        

            

                2190
            

            

                
            

            

                
                                                                let v131 = C::unpack_value_array_2(

            

        

            

                2191
            

            

                
            

            

                
                                                                    ctx, v130,

            

        

            

                2192
            

            

                
            

            

                
                                                                );

            

        

            

                2193
            

            

                
            

            

                
                                                                if v37 == v131.1 {

            

        

            

                2194
            

            

                
            

            

                
                                                                    let v134 = constructor_bor(

            

        

            

                2195
            

            

                
            

            

                
                                                                        ctx, v2.0, v131.0, v7.0,

            

        

            

                2196
            

            

                
            

            

                
                                                                    );

            

        

            

                2197
            

            

                
            

            

                
                                                                    // Rule at src/opts/bitops.isle line 73.

            

        

            

                2198
            

            

                
            

            

                
                                                                    returns.push(v134);

            

        

            

                2199
            

            

                
            

            

                
                                                                }

            

        

            

                2200
            

            

                
            

            

                
                                                            }

            

        

            

                2201
            

            

                
            

            

                
                                                        }

            

        

            

                2202
            

            

                
            

            

                
                                                    }

            

        

            

                2203
            

            

                
            

            

                
                                                }

            

        

            

                2204
            

            

                
            

            

                
                                            }

            

        

            

                2205
            

            

                
            

            

                
                                        }

            

        

            

                2206
            

            

                
            

            

                
                                        _ => {}

            

        

            

                2207
            

            

                
            

            

                
                                    }

            

        

            

                2208
            

            

                
            

            

                
                                }

            

        

            

                2209
            

            

                
            

            

                
                                &InstructionData::UnaryImm {

            

        

            

                2210
            

            

                
            

            

                
                                    opcode: ref v22,

            

        

            

                2211
            

            

                
            

            

                
                                    imm: v23,

            

        

            

                2212
            

            

                
            

            

                
                                } => {

            

        

            

                2213
            

            

                
            

            

                
                                    if let &Opcode::Iconst = v22 {

            

        

            

                2214
            

            

                
            

            

                
                                        if v2.0 == v19.0 {

            

        

            

                2215
            

            

                
            

            

                
                                            let v24 = C::u64_from_imm64(ctx, v23);

            

        

            

                2216
            

            

                
            

            

                
                                            if v24 == 0x0 {

            

        

            

                2217
            

            

                
            

            

                
                                                let v25 = C::subsume(ctx, v7.1);

            

        

            

                2218
            

            

                
            

            

                
                                                // Rule at src/opts/bitops.isle line 8.

            

        

            

                2219
            

            

                
            

            

                
                                                returns.push(v25);

            

        

            

                2220
            

            

                
            

            

                
                                            }

            

        

            

                2221
            

            

                
            

            

                
                                            let v265 = constructor_bor(ctx, v2.0, v7.1, v7.0);

            

        

            

                2222
            

            

                
            

            

                
                                            // Rule at src/opts/cprop.isle line 106.

            

        

            

                2223
            

            

                
            

            

                
                                            returns.push(v265);

            

        

            

                2224
            

            

                
            

            

                
                                        }

            

        

            

                2225
            

            

                
            

            

                
                                        let v44 = C::fits_in_64(ctx, v2.0);

            

        

            

                2226
            

            

                
            

            

                
                                        if let Some(v45) = v44 {

            

        

            

                2227
            

            

                
            

            

                
                                            if v19.0 == v45 {

            

        

            

                2228
            

            

                
            

            

                
                                                let v10 = C::inst_data_etor(ctx, v7.1);

            

        

            

                2229
            

            

                
            

            

                
                                                let mut v10 = v10;

            

        

            

                2230
            

            

                
            

            

                
                                                while let Some(v11) = v10.next(ctx) {

            

        

            

                2231
            

            

                
            

            

                
                                                    if let &InstructionData::UnaryImm {

            

        

            

                2232
            

            

                
            

            

                
                                                        opcode: ref v14,

            

        

            

                2233
            

            

                
            

            

                
                                                        imm: v15,

            

        

            

                2234
            

            

                
            

            

                
                                                    } = &v11.1

            

        

            

                2235
            

            

                
            

            

                
                                                    {

            

        

            

                2236
            

            

                
            

            

                
                                                        if let &Opcode::Iconst = v14 {

            

        

            

                2237
            

            

                
            

            

                
                                                            if v11.0 == v19.0 {

            

        

            

                2238
            

            

                
            

            

                
                                                                let v24 =

            

        

            

                2239
            

            

                
            

            

                
                                                                    C::u64_from_imm64(ctx, v23);

            

        

            

                2240
            

            

                
            

            

                
                                                                let v16 =

            

        

            

                2241
            

            

                
            

            

                
                                                                    C::u64_from_imm64(ctx, v15);

            

        

            

                2242
            

            

                
            

            

                
                                                                let v210 = C::u64_or(ctx, v24, v16);

            

        

            

                2243
            

            

                
            

            

                
                                                                let v211 =

            

        

            

                2244
            

            

                
            

            

                
                                                                    C::imm64_masked(ctx, v45, v210);

            

        

            

                2245
            

            

                
            

            

                
                                                                let v212 = constructor_iconst(

            

        

            

                2246
            

            

                
            

            

                
                                                                    ctx, v45, v211,

            

        

            

                2247
            

            

                
            

            

                
                                                                );

            

        

            

                2248
            

            

                
            

            

                
                                                                let v213 = C::subsume(ctx, v212);

            

        

            

                2249
            

            

                
            

            

                
                                                                // Rule at src/opts/cprop.isle line 35.

            

        

            

                2250
            

            

                
            

            

                
                                                                returns.push(v213);

            

        

            

                2251
            

            

                
            

            

                
                                                            }

            

        

            

                2252
            

            

                
            

            

                
                                                        }

            

        

            

                2253
            

            

                
            

            

                
                                                    }

            

        

            

                2254
            

            

                
            

            

                
                                                }

            

        

            

                2255
            

            

                
            

            

                
                                            }

            

        

            

                2256
            

            

                
            

            

                
                                        }

            

        

            

                2257
            

            

                
            

            

                
                                        let v413 = C::remat(ctx, arg0);

            

        

            

                2258
            

            

                
            

            

                
                                        // Rule at src/opts/remat.isle line 16.

            

        

            

                2259
            

            

                
            

            

                
                                        returns.push(v413);

            

        

            

                2260
            

            

                
            

            

                
                                    }

            

        

            

                2261
            

            

                
            

            

                
                                }

            

        

            

                2262
            

            

                
            

            

                
                                _ => {}

            

        

            

                2263
            

            

                
            

            

                
                            }

            

        

            

                2264
            

            

                
            

            

                
                        }

            

        

            

                2265
            

            

                
            

            

                
                        let v10 = C::inst_data_etor(ctx, v7.1);

            

        

            

                2266
            

            

                
            

            

                
                        let mut v10 = v10;

            

        

            

                2267
            

            

                
            

            

                
                        while let Some(v11) = v10.next(ctx) {

            

        

            

                2268
            

            

                
            

            

                
                            match &v11.1 {

            

        

            

                2269
            

            

                
            

            

                
                                &InstructionData::Unary {

            

        

            

                2270
            

            

                
            

            

                
                                    opcode: ref v38,

            

        

            

                2271
            

            

                
            

            

                
                                    arg: v39,

            

        

            

                2272
            

            

                
            

            

                
                                } => {

            

        

            

                2273
            

            

                
            

            

                
                                    if let &Opcode::Bnot = v38 {

            

        

            

                2274
            

            

                
            

            

                
                                        if v7.0 == v39 {

            

        

            

                2275
            

            

                
            

            

                
                                            let v44 = C::fits_in_64(ctx, v2.0);

            

        

            

                2276
            

            

                
            

            

                
                                            if let Some(v45) = v44 {

            

        

            

                2277
            

            

                
            

            

                
                                                let v46 = C::ty_int(ctx, v45);

            

        

            

                2278
            

            

                
            

            

                
                                                if let Some(v47) = v46 {

            

        

            

                2279
            

            

                
            

            

                
                                                    if v11.0 == v47 {

            

        

            

                2280
            

            

                
            

            

                
                                                        let v115 = C::ty_mask(ctx, v47);

            

        

            

                2281
            

            

                
            

            

                
                                                        let v116 = C::imm64(ctx, v115);

            

        

            

                2282
            

            

                
            

            

                
                                                        let v117 =

            

        

            

                2283
            

            

                
            

            

                
                                                            constructor_iconst(ctx, v47, v116);

            

        

            

                2284
            

            

                
            

            

                
                                                        let v118 = C::subsume(ctx, v117);

            

        

            

                2285
            

            

                
            

            

                
                                                        // Rule at src/opts/bitops.isle line 34.

            

        

            

                2286
            

            

                
            

            

                
                                                        returns.push(v118);

            

        

            

                2287
            

            

                
            

            

                
                                                    }

            

        

            

                2288
            

            

                
            

            

                
                                                }

            

        

            

                2289
            

            

                
            

            

                
                                            }

            

        

            

                2290
            

            

                
            

            

                
                                        }

            

        

            

                2291
            

            

                
            

            

                
                                    }

            

        

            

                2292
            

            

                
            

            

                
                                }

            

        

            

                2293
            

            

                
            

            

                
                                &InstructionData::UnaryImm {

            

        

            

                2294
            

            

                
            

            

                
                                    opcode: ref v14,

            

        

            

                2295
            

            

                
            

            

                
                                    imm: v15,

            

        

            

                2296
            

            

                
            

            

                
                                } => {

            

        

            

                2297
            

            

                
            

            

                
                                    if let &Opcode::Iconst = v14 {

            

        

            

                2298
            

            

                
            

            

                
                                        let v16 = C::u64_from_imm64(ctx, v15);

            

        

            

                2299
            

            

                
            

            

                
                                        if v16 == 0x0 {

            

        

            

                2300
            

            

                
            

            

                
                                            if v2.0 == v11.0 {

            

        

            

                2301
            

            

                
            

            

                
                                                let v17 = C::subsume(ctx, v7.0);

            

        

            

                2302
            

            

                
            

            

                
                                                // Rule at src/opts/bitops.isle line 4.

            

        

            

                2303
            

            

                
            

            

                
                                                returns.push(v17);

            

        

            

                2304
            

            

                
            

            

                
                                            }

            

        

            

                2305
            

            

                
            

            

                
                                        }

            

        

            

                2306
            

            

                
            

            

                
                                        let v413 = C::remat(ctx, arg0);

            

        

            

                2307
            

            

                
            

            

                
                                        // Rule at src/opts/remat.isle line 18.

            

        

            

                2308
            

            

                
            

            

                
                                        returns.push(v413);

            

        

            

                2309
            

            

                
            

            

                
                                    }

            

        

            

                2310
            

            

                
            

            

                
                                }

            

        

            

                2311
            

            

                
            

            

                
                                _ => {}

            

        

            

                2312
            

            

                
            

            

                
                            }

            

        

            

                2313
            

            

                
            

            

                
                        }

            

        

            

                2314
            

            

                
            

            

                
                        if v7.0 == v7.1 {

            

        

            

                2315
            

            

                
            

            

                
                            let v17 = C::subsume(ctx, v7.0);

            

        

            

                2316
            

            

                
            

            

                
                            // Rule at src/opts/bitops.isle line 12.

            

        

            

                2317
            

            

                
            

            

                
                            returns.push(v17);

            

        

            

                2318
            

            

                
            

            

                
                        }

            

        

            

                2319
            

            

                
            

            

                
                    }

            

        

            

                2320
            

            

                
            

            

                
                    &Opcode::Bxor => {

            

        

            

                2321
            

            

                
            

            

                
                        let v7 = C::unpack_value_array_2(ctx, v6);

            

        

            

                2322
            

            

                
            

            

                
                        let v10 = C::inst_data_etor(ctx, v7.1);

            

        

            

                2323
            

            

                
            

            

                
                        let mut v10 = v10;

            

        

            

                2324
            

            

                
            

            

                
                        while let Some(v11) = v10.next(ctx) {

            

        

            

                2325
            

            

                
            

            

                
                            match &v11.1 {

            

        

            

                2326
            

            

                
            

            

                
                                &InstructionData::Unary {

            

        

            

                2327
            

            

                
            

            

                
                                    opcode: ref v38,

            

        

            

                2328
            

            

                
            

            

                
                                    arg: v39,

            

        

            

                2329
            

            

                
            

            

                
                                } => {

            

        

            

                2330
            

            

                
            

            

                
                                    match v38 {

            

        

            

                2331
            

            

                
            

            

                
                                        &Opcode::Splat => {

            

        

            

                2332
            

            

                
            

            

                
                                            let v486 = C::ty_vector_not_float(ctx, v2.0);

            

        

            

                2333
            

            

                
            

            

                
                                            if let Some(v487) = v486 {

            

        

            

                2334
            

            

                
            

            

                
                                                if v2.0 == v11.0 {

            

        

            

                2335
            

            

                
            

            

                
                                                    let v18 = C::inst_data_etor(ctx, v7.0);

            

        

            

                2336
            

            

                
            

            

                
                                                    let mut v18 = v18;

            

        

            

                2337
            

            

                
            

            

                
                                                    while let Some(v19) = v18.next(ctx) {

            

        

            

                2338
            

            

                
            

            

                
                                                        if let &InstructionData::Unary {

            

        

            

                2339
            

            

                
            

            

                
                                                            opcode: ref v36,

            

        

            

                2340
            

            

                
            

            

                
                                                            arg: v37,

            

        

            

                2341
            

            

                
            

            

                
                                                        } = &v19.1

            

        

            

                2342
            

            

                
            

            

                
                                                        {

            

        

            

                2343
            

            

                
            

            

                
                                                            if let &Opcode::Splat = v36 {

            

        

            

                2344
            

            

                
            

            

                
                                                                if v2.0 == v19.0 {

            

        

            

                2345
            

            

                
            

            

                
                                                                    let v481 =

            

        

            

                2346
            

            

                
            

            

                
                                                                        C::lane_type(ctx, v2.0);

            

        

            

                2347
            

            

                
            

            

                
                                                                    let v492 = constructor_bxor(

            

        

            

                2348
            

            

                
            

            

                
                                                                        ctx, v481, v37, v39,

            

        

            

                2349
            

            

                
            

            

                
                                                                    );

            

        

            

                2350
            

            

                
            

            

                
                                                                    let v493 = constructor_splat(

            

        

            

                2351
            

            

                
            

            

                
                                                                        ctx, v2.0, v492,

            

        

            

                2352
            

            

                
            

            

                
                                                                    );

            

        

            

                2353
            

            

                
            

            

                
                                                                    // Rule at src/opts/vector.isle line 22.

            

        

            

                2354
            

            

                
            

            

                
                                                                    returns.push(v493);

            

        

            

                2355
            

            

                
            

            

                
                                                                }

            

        

            

                2356
            

            

                
            

            

                
                                                            }

            

        

            

                2357
            

            

                
            

            

                
                                                        }

            

        

            

                2358
            

            

                
            

            

                
                                                    }

            

        

            

                2359
            

            

                
            

            

                
                                                }

            

        

            

                2360
            

            

                
            

            

                
                                            }

            

        

            

                2361
            

            

                
            

            

                
                                        }

            

        

            

                2362
            

            

                
            

            

                
                                        &Opcode::Bnot => {

            

        

            

                2363
            

            

                
            

            

                
                                            let v44 = C::fits_in_64(ctx, v2.0);

            

        

            

                2364
            

            

                
            

            

                
                                            if let Some(v45) = v44 {

            

        

            

                2365
            

            

                
            

            

                
                                                let v46 = C::ty_int(ctx, v45);

            

        

            

                2366
            

            

                
            

            

                
                                                if let Some(v47) = v46 {

            

        

            

                2367
            

            

                
            

            

                
                                                    if v7.0 == v39 {

            

        

            

                2368
            

            

                
            

            

                
                                                        if v11.0 == v47 {

            

        

            

                2369
            

            

                
            

            

                
                                                            let v115 = C::ty_mask(ctx, v47);

            

        

            

                2370
            

            

                
            

            

                
                                                            let v116 = C::imm64(ctx, v115);

            

        

            

                2371
            

            

                
            

            

                
                                                            let v117 =

            

        

            

                2372
            

            

                
            

            

                
                                                                constructor_iconst(ctx, v47, v116);

            

        

            

                2373
            

            

                
            

            

                
                                                            let v118 = C::subsume(ctx, v117);

            

        

            

                2374
            

            

                
            

            

                
                                                            // Rule at src/opts/bitops.isle line 32.

            

        

            

                2375
            

            

                
            

            

                
                                                            returns.push(v118);

            

        

            

                2376
            

            

                
            

            

                
                                                        }

            

        

            

                2377
            

            

                
            

            

                
                                                    }

            

        

            

                2378
            

            

                
            

            

                
                                                }

            

        

            

                2379
            

            

                
            

            

                
                                            }

            

        

            

                2380
            

            

                
            

            

                
                                        }

            

        

            

                2381
            

            

                
            

            

                
                                        _ => {}

            

        

            

                2382
            

            

                
            

            

                
                                    }

            

        

            

                2383
            

            

                
            

            

                
                                }

            

        

            

                2384
            

            

                
            

            

                
                                &InstructionData::UnaryImm {

            

        

            

                2385
            

            

                
            

            

                
                                    opcode: ref v14,

            

        

            

                2386
            

            

                
            

            

                
                                    imm: v15,

            

        

            

                2387
            

            

                
            

            

                
                                } => {

            

        

            

                2388
            

            

                
            

            

                
                                    if let &Opcode::Iconst = v14 {

            

        

            

                2389
            

            

                
            

            

                
                                        if v2.0 == v11.0 {

            

        

            

                2390
            

            

                
            

            

                
                                            let v16 = C::u64_from_imm64(ctx, v15);

            

        

            

                2391
            

            

                
            

            

                
                                            if v16 == 0x0 {

            

        

            

                2392
            

            

                
            

            

                
                                                let v17 = C::subsume(ctx, v7.0);

            

        

            

                2393
            

            

                
            

            

                
                                                // Rule at src/opts/bitops.isle line 16.

            

        

            

                2394
            

            

                
            

            

                
                                                returns.push(v17);

            

        

            

                2395
            

            

                
            

            

                
                                            }

            

        

            

                2396
            

            

                
            

            

                
                                            let v52 = C::i64_sextend_imm64(ctx, v2.0, v15);

            

        

            

                2397
            

            

                
            

            

                
                                            if v52 == -0x1 {

            

        

            

                2398
            

            

                
            

            

                
                                                let v147 = constructor_bnot(ctx, v2.0, v7.0);

            

        

            

                2399
            

            

                
            

            

                
                                                // Rule at src/opts/bitops.isle line 92.

            

        

            

                2400
            

            

                
            

            

                
                                                returns.push(v147);

            

        

            

                2401
            

            

                
            

            

                
                                            }

            

        

            

                2402
            

            

                
            

            

                
                                            let v18 = C::inst_data_etor(ctx, v7.0);

            

        

            

                2403
            

            

                
            

            

                
                                            let mut v18 = v18;

            

        

            

                2404
            

            

                
            

            

                
                                            while let Some(v19) = v18.next(ctx) {

            

        

            

                2405
            

            

                
            

            

                
                                                if let &InstructionData::Binary {

            

        

            

                2406
            

            

                
            

            

                
                                                    opcode: ref v123,

            

        

            

                2407
            

            

                
            

            

                
                                                    args: ref v124,

            

        

            

                2408
            

            

                
            

            

                
                                                } = &v19.1

            

        

            

                2409
            

            

                
            

            

                
                                                {

            

        

            

                2410
            

            

                
            

            

                
                                                    if let &Opcode::Bxor = v123 {

            

        

            

                2411
            

            

                
            

            

                
                                                        if v2.0 == v19.0 {

            

        

            

                2412
            

            

                
            

            

                
                                                            let v125 =

            

        

            

                2413
            

            

                
            

            

                
                                                                C::unpack_value_array_2(ctx, v124);

            

        

            

                2414
            

            

                
            

            

                
                                                            let v135 =

            

        

            

                2415
            

            

                
            

            

                
                                                                C::inst_data_etor(ctx, v125.1);

            

        

            

                2416
            

            

                
            

            

                
                                                            let mut v135 = v135;

            

        

            

                2417
            

            

                
            

            

                
                                                            while let Some(v136) = v135.next(ctx) {

            

        

            

                2418
            

            

                
            

            

                
                                                                if let &InstructionData::UnaryImm {

            

        

            

                2419
            

            

                
            

            

                
                                                                    opcode: ref v139,

            

        

            

                2420
            

            

                
            

            

                
                                                                    imm: v140,

            

        

            

                2421
            

            

                
            

            

                
                                                                } = &v136.1 {

            

        

            

                2422
            

            

                
            

            

                
                                                                    if let &Opcode::Iconst = v139 {

            

        

            

                2423
            

            

                
            

            

                
                                                                        if v2.0 == v136.0 {

            

        

            

                2424
            

            

                
            

            

                
                                                                            let v298 = constructor_bxor(ctx, v2.0, v125.1, v7.1);

            

        

            

                2425
            

            

                
            

            

                
                                                                            let v299 = constructor_bxor(ctx, v2.0, v125.0, v298);

            

        

            

                2426
            

            

                
            

            

                
                                                                            // Rule at src/opts/cprop.isle line 165.

            

        

            

                2427
            

            

                
            

            

                
                                                                            returns.push(v299);

            

        

            

                2428
            

            

                
            

            

                
                                                                        }

            

        

            

                2429
            

            

                
            

            

                
                                                                    }

            

        

            

                2430
            

            

                
            

            

                
                                                                }

            

        

            

                2431
            

            

                
            

            

                
                                                            }

            

        

            

                2432
            

            

                
            

            

                
                                                        }

            

        

            

                2433
            

            

                
            

            

                
                                                    }

            

        

            

                2434
            

            

                
            

            

                
                                                }

            

        

            

                2435
            

            

                
            

            

                
                                            }

            

        

            

                2436
            

            

                
            

            

                
                                        }

            

        

            

                2437
            

            

                
            

            

                
                                        let v44 = C::fits_in_64(ctx, v2.0);

            

        

            

                2438
            

            

                
            

            

                
                                        if let Some(v45) = v44 {

            

        

            

                2439
            

            

                
            

            

                
                                            if v11.0 == v45 {

            

        

            

                2440
            

            

                
            

            

                
                                                let v18 = C::inst_data_etor(ctx, v7.0);

            

        

            

                2441
            

            

                
            

            

                
                                                let mut v18 = v18;

            

        

            

                2442
            

            

                
            

            

                
                                                while let Some(v19) = v18.next(ctx) {

            

        

            

                2443
            

            

                
            

            

                
                                                    if let &InstructionData::UnaryImm {

            

        

            

                2444
            

            

                
            

            

                
                                                        opcode: ref v22,

            

        

            

                2445
            

            

                
            

            

                
                                                        imm: v23,

            

        

            

                2446
            

            

                
            

            

                
                                                    } = &v19.1

            

        

            

                2447
            

            

                
            

            

                
                                                    {

            

        

            

                2448
            

            

                
            

            

                
                                                        if let &Opcode::Iconst = v22 {

            

        

            

                2449
            

            

                
            

            

                
                                                            if v11.0 == v19.0 {

            

        

            

                2450
            

            

                
            

            

                
                                                                let v24 =

            

        

            

                2451
            

            

                
            

            

                
                                                                    C::u64_from_imm64(ctx, v23);

            

        

            

                2452
            

            

                
            

            

                
                                                                let v16 =

            

        

            

                2453
            

            

                
            

            

                
                                                                    C::u64_from_imm64(ctx, v15);

            

        

            

                2454
            

            

                
            

            

                
                                                                let v218 =

            

        

            

                2455
            

            

                
            

            

                
                                                                    C::u64_xor(ctx, v24, v16);

            

        

            

                2456
            

            

                
            

            

                
                                                                let v219 =

            

        

            

                2457
            

            

                
            

            

                
                                                                    C::imm64_masked(ctx, v45, v218);

            

        

            

                2458
            

            

                
            

            

                
                                                                let v220 = constructor_iconst(

            

        

            

                2459
            

            

                
            

            

                
                                                                    ctx, v45, v219,

            

        

            

                2460
            

            

                
            

            

                
                                                                );

            

        

            

                2461
            

            

                
            

            

                
                                                                let v221 = C::subsume(ctx, v220);

            

        

            

                2462
            

            

                
            

            

                
                                                                // Rule at src/opts/cprop.isle line 47.

            

        

            

                2463
            

            

                
            

            

                
                                                                returns.push(v221);

            

        

            

                2464
            

            

                
            

            

                
                                                            }

            

        

            

                2465
            

            

                
            

            

                
                                                        }

            

        

            

                2466
            

            

                
            

            

                
                                                    }

            

        

            

                2467
            

            

                
            

            

                
                                                }

            

        

            

                2468
            

            

                
            

            

                
                                            }

            

        

            

                2469
            

            

                
            

            

                
                                        }

            

        

            

                2470
            

            

                
            

            

                
                                        let v413 = C::remat(ctx, arg0);

            

        

            

                2471
            

            

                
            

            

                
                                        // Rule at src/opts/remat.isle line 22.

            

        

            

                2472
            

            

                
            

            

                
                                        returns.push(v413);

            

        

            

                2473
            

            

                
            

            

                
                                    }

            

        

            

                2474
            

            

                
            

            

                
                                }

            

        

            

                2475
            

            

                
            

            

                
                                _ => {}

            

        

            

                2476
            

            

                
            

            

                
                            }

            

        

            

                2477
            

            

                
            

            

                
                        }

            

        

            

                2478
            

            

                
            

            

                
                        let v18 = C::inst_data_etor(ctx, v7.0);

            

        

            

                2479
            

            

                
            

            

                
                        let mut v18 = v18;

            

        

            

                2480
            

            

                
            

            

                
                        while let Some(v19) = v18.next(ctx) {

            

        

            

                2481
            

            

                
            

            

                
                            match &v19.1 {

            

        

            

                2482
            

            

                
            

            

                
                                &InstructionData::Unary {

            

        

            

                2483
            

            

                
            

            

                
                                    opcode: ref v36,

            

        

            

                2484
            

            

                
            

            

                
                                    arg: v37,

            

        

            

                2485
            

            

                
            

            

                
                                } => {

            

        

            

                2486
            

            

                
            

            

                
                                    if let &Opcode::Bnot = v36 {

            

        

            

                2487
            

            

                
            

            

                
                                        if v7.1 == v37 {

            

        

            

                2488
            

            

                
            

            

                
                                            let v44 = C::fits_in_64(ctx, v2.0);

            

        

            

                2489
            

            

                
            

            

                
                                            if let Some(v45) = v44 {

            

        

            

                2490
            

            

                
            

            

                
                                                let v46 = C::ty_int(ctx, v45);

            

        

            

                2491
            

            

                
            

            

                
                                                if let Some(v47) = v46 {

            

        

            

                2492
            

            

                
            

            

                
                                                    if v19.0 == v47 {

            

        

            

                2493
            

            

                
            

            

                
                                                        let v115 = C::ty_mask(ctx, v47);

            

        

            

                2494
            

            

                
            

            

                
                                                        let v116 = C::imm64(ctx, v115);

            

        

            

                2495
            

            

                
            

            

                
                                                        let v117 =

            

        

            

                2496
            

            

                
            

            

                
                                                            constructor_iconst(ctx, v47, v116);

            

        

            

                2497
            

            

                
            

            

                
                                                        let v118 = C::subsume(ctx, v117);

            

        

            

                2498
            

            

                
            

            

                
                                                        // Rule at src/opts/bitops.isle line 33.

            

        

            

                2499
            

            

                
            

            

                
                                                        returns.push(v118);

            

        

            

                2500
            

            

                
            

            

                
                                                    }

            

        

            

                2501
            

            

                
            

            

                
                                                }

            

        

            

                2502
            

            

                
            

            

                
                                            }

            

        

            

                2503
            

            

                
            

            

                
                                        }

            

        

            

                2504
            

            

                
            

            

                
                                    }

            

        

            

                2505
            

            

                
            

            

                
                                }

            

        

            

                2506
            

            

                
            

            

                
                                &InstructionData::UnaryImm {

            

        

            

                2507
            

            

                
            

            

                
                                    opcode: ref v22,

            

        

            

                2508
            

            

                
            

            

                
                                    imm: v23,

            

        

            

                2509
            

            

                
            

            

                
                                } => {

            

        

            

                2510
            

            

                
            

            

                
                                    if let &Opcode::Iconst = v22 {

            

        

            

                2511
            

            

                
            

            

                
                                        if v2.0 == v19.0 {

            

        

            

                2512
            

            

                
            

            

                
                                            let v24 = C::u64_from_imm64(ctx, v23);

            

        

            

                2513
            

            

                
            

            

                
                                            if v24 == 0x0 {

            

        

            

                2514
            

            

                
            

            

                
                                                let v25 = C::subsume(ctx, v7.1);

            

        

            

                2515
            

            

                
            

            

                
                                                // Rule at src/opts/bitops.isle line 20.

            

        

            

                2516
            

            

                
            

            

                
                                                returns.push(v25);

            

        

            

                2517
            

            

                
            

            

                
                                            }

            

        

            

                2518
            

            

                
            

            

                
                                            let v267 = constructor_bxor(ctx, v2.0, v7.1, v7.0);

            

        

            

                2519
            

            

                
            

            

                
                                            // Rule at src/opts/cprop.isle line 112.

            

        

            

                2520
            

            

                
            

            

                
                                            returns.push(v267);

            

        

            

                2521
            

            

                
            

            

                
                                        }

            

        

            

                2522
            

            

                
            

            

                
                                        let v413 = C::remat(ctx, arg0);

            

        

            

                2523
            

            

                
            

            

                
                                        // Rule at src/opts/remat.isle line 20.

            

        

            

                2524
            

            

                
            

            

                
                                        returns.push(v413);

            

        

            

                2525
            

            

                
            

            

                
                                    }

            

        

            

                2526
            

            

                
            

            

                
                                }

            

        

            

                2527
            

            

                
            

            

                
                                _ => {}

            

        

            

                2528
            

            

                
            

            

                
                            }

            

        

            

                2529
            

            

                
            

            

                
                        }

            

        

            

                2530
            

            

                
            

            

                
                        if v7.0 == v7.1 {

            

        

            

                2531
            

            

                
            

            

                
                            let v44 = C::fits_in_64(ctx, v2.0);

            

        

            

                2532
            

            

                
            

            

                
                            if let Some(v45) = v44 {

            

        

            

                2533
            

            

                
            

            

                
                                let v46 = C::ty_int(ctx, v45);

            

        

            

                2534
            

            

                
            

            

                
                                if let Some(v47) = v46 {

            

        

            

                2535
            

            

                
            

            

                
                                    let v49 = C::imm64(ctx, 0x0);

            

        

            

                2536
            

            

                
            

            

                
                                    let v50 = constructor_iconst(ctx, v47, v49);

            

        

            

                2537
            

            

                
            

            

                
                                    let v51 = C::subsume(ctx, v50);

            

        

            

                2538
            

            

                
            

            

                
                                    // Rule at src/opts/bitops.isle line 26.

            

        

            

                2539
            

            

                
            

            

                
                                    returns.push(v51);

            

        

            

                2540
            

            

                
            

            

                
                                }

            

        

            

                2541
            

            

                
            

            

                
                            }

            

        

            

                2542
            

            

                
            

            

                
                        }

            

        

            

                2543
            

            

                
            

            

                
                    }

            

        

            

                2544
            

            

                
            

            

                
                    &Opcode::Rotl => {

            

        

            

                2545
            

            

                
            

            

                
                        let v7 = C::unpack_value_array_2(ctx, v6);

            

        

            

                2546
            

            

                
            

            

                
                        let v10 = C::inst_data_etor(ctx, v7.1);

            

        

            

                2547
            

            

                
            

            

                
                        let mut v10 = v10;

            

        

            

                2548
            

            

                
            

            

                
                        while let Some(v11) = v10.next(ctx) {

            

        

            

                2549
            

            

                
            

            

                
                            if let &InstructionData::UnaryImm {

            

        

            

                2550
            

            

                
            

            

                
                                opcode: ref v14,

            

        

            

                2551
            

            

                
            

            

                
                                imm: v15,

            

        

            

                2552
            

            

                
            

            

                
                            } = &v11.1

            

        

            

                2553
            

            

                
            

            

                
                            {

            

        

            

                2554
            

            

                
            

            

                
                                if let &Opcode::Iconst = v14 {

            

        

            

                2555
            

            

                
            

            

                
                                    let v16 = C::u64_from_imm64(ctx, v15);

            

        

            

                2556
            

            

                
            

            

                
                                    if v16 == 0x0 {

            

        

            

                2557
            

            

                
            

            

                
                                        if v2.0 == v11.0 {

            

        

            

                2558
            

            

                
            

            

                
                                            let v17 = C::subsume(ctx, v7.0);

            

        

            

                2559
            

            

                
            

            

                
                                            // Rule at src/opts/shifts.isle line 20.

            

        

            

                2560
            

            

                
            

            

                
                                            returns.push(v17);

            

        

            

                2561
            

            

                
            

            

                
                                        }

            

        

            

                2562
            

            

                
            

            

                
                                    }

            

        

            

                2563
            

            

                
            

            

                
                                }

            

        

            

                2564
            

            

                
            

            

                
                            }

            

        

            

                2565
            

            

                
            

            

                
                        }

            

        

            

                2566
            

            

                
            

            

                
                        let v18 = C::inst_data_etor(ctx, v7.0);

            

        

            

                2567
            

            

                
            

            

                
                        let mut v18 = v18;

            

        

            

                2568
            

            

                
            

            

                
                        while let Some(v19) = v18.next(ctx) {

            

        

            

                2569
            

            

                
            

            

                
                            if let &InstructionData::Unary {

            

        

            

                2570
            

            

                
            

            

                
                                opcode: ref v36,

            

        

            

                2571
            

            

                
            

            

                
                                arg: v37,

            

        

            

                2572
            

            

                
            

            

                
                            } = &v19.1

            

        

            

                2573
            

            

                
            

            

                
                            {

            

        

            

                2574
            

            

                
            

            

                
                                if let &Opcode::Splat = v36 {

            

        

            

                2575
            

            

                
            

            

                
                                    if v2.0 == v19.0 {

            

        

            

                2576
            

            

                
            

            

                
                                        let v481 = C::lane_type(ctx, v2.0);

            

        

            

                2577
            

            

                
            

            

                
                                        let v520 = constructor_rotl(ctx, v481, v37, v7.1);

            

        

            

                2578
            

            

                
            

            

                
                                        let v521 = constructor_splat(ctx, v2.0, v520);

            

        

            

                2579
            

            

                
            

            

                
                                        // Rule at src/opts/vector.isle line 68.

            

        

            

                2580
            

            

                
            

            

                
                                        returns.push(v521);

            

        

            

                2581
            

            

                
            

            

                
                                    }

            

        

            

                2582
            

            

                
            

            

                
                                }

            

        

            

                2583
            

            

                
            

            

                
                            }

            

        

            

                2584
            

            

                
            

            

                
                        }

            

        

            

                2585
            

            

                
            

            

                
                    }

            

        

            

                2586
            

            

                
            

            

                
                    &Opcode::Rotr => {

            

        

            

                2587
            

            

                
            

            

                
                        let v7 = C::unpack_value_array_2(ctx, v6);

            

        

            

                2588
            

            

                
            

            

                
                        let v10 = C::inst_data_etor(ctx, v7.1);

            

        

            

                2589
            

            

                
            

            

                
                        let mut v10 = v10;

            

        

            

                2590
            

            

                
            

            

                
                        while let Some(v11) = v10.next(ctx) {

            

        

            

                2591
            

            

                
            

            

                
                            if let &InstructionData::UnaryImm {

            

        

            

                2592
            

            

                
            

            

                
                                opcode: ref v14,

            

        

            

                2593
            

            

                
            

            

                
                                imm: v15,

            

        

            

                2594
            

            

                
            

            

                
                            } = &v11.1

            

        

            

                2595
            

            

                
            

            

                
                            {

            

        

            

                2596
            

            

                
            

            

                
                                if let &Opcode::Iconst = v14 {

            

        

            

                2597
            

            

                
            

            

                
                                    let v16 = C::u64_from_imm64(ctx, v15);

            

        

            

                2598
            

            

                
            

            

                
                                    if v16 == 0x0 {

            

        

            

                2599
            

            

                
            

            

                
                                        if v2.0 == v11.0 {

            

        

            

                2600
            

            

                
            

            

                
                                            let v17 = C::subsume(ctx, v7.0);

            

        

            

                2601
            

            

                
            

            

                
                                            // Rule at src/opts/shifts.isle line 16.

            

        

            

                2602
            

            

                
            

            

                
                                            returns.push(v17);

            

        

            

                2603
            

            

                
            

            

                
                                        }

            

        

            

                2604
            

            

                
            

            

                
                                    }

            

        

            

                2605
            

            

                
            

            

                
                                }

            

        

            

                2606
            

            

                
            

            

                
                            }

            

        

            

                2607
            

            

                
            

            

                
                        }

            

        

            

                2608
            

            

                
            

            

                
                        let v18 = C::inst_data_etor(ctx, v7.0);

            

        

            

                2609
            

            

                
            

            

                
                        let mut v18 = v18;

            

        

            

                2610
            

            

                
            

            

                
                        while let Some(v19) = v18.next(ctx) {

            

        

            

                2611
            

            

                
            

            

                
                            if let &InstructionData::Unary {

            

        

            

                2612
            

            

                
            

            

                
                                opcode: ref v36,

            

        

            

                2613
            

            

                
            

            

                
                                arg: v37,

            

        

            

                2614
            

            

                
            

            

                
                            } = &v19.1

            

        

            

                2615
            

            

                
            

            

                
                            {

            

        

            

                2616
            

            

                
            

            

                
                                if let &Opcode::Splat = v36 {

            

        

            

                2617
            

            

                
            

            

                
                                    if v2.0 == v19.0 {

            

        

            

                2618
            

            

                
            

            

                
                                        let v481 = C::lane_type(ctx, v2.0);

            

        

            

                2619
            

            

                
            

            

                
                                        let v522 = constructor_rotr(ctx, v481, v37, v7.1);

            

        

            

                2620
            

            

                
            

            

                
                                        let v523 = constructor_splat(ctx, v2.0, v522);

            

        

            

                2621
            

            

                
            

            

                
                                        // Rule at src/opts/vector.isle line 71.

            

        

            

                2622
            

            

                
            

            

                
                                        returns.push(v523);

            

        

            

                2623
            

            

                
            

            

                
                                    }

            

        

            

                2624
            

            

                
            

            

                
                                }

            

        

            

                2625
            

            

                
            

            

                
                            }

            

        

            

                2626
            

            

                
            

            

                
                        }

            

        

            

                2627
            

            

                
            

            

                
                    }

            

        

            

                2628
            

            

                
            

            

                
                    &Opcode::Ishl => {

            

        

            

                2629
            

            

                
            

            

                
                        let v7 = C::unpack_value_array_2(ctx, v6);

            

        

            

                2630
            

            

                
            

            

                
                        let v10 = C::inst_data_etor(ctx, v7.1);

            

        

            

                2631
            

            

                
            

            

                
                        let mut v10 = v10;

            

        

            

                2632
            

            

                
            

            

                
                        while let Some(v11) = v10.next(ctx) {

            

        

            

                2633
            

            

                
            

            

                
                            if let &InstructionData::UnaryImm {

            

        

            

                2634
            

            

                
            

            

                
                                opcode: ref v14,

            

        

            

                2635
            

            

                
            

            

                
                                imm: v15,

            

        

            

                2636
            

            

                
            

            

                
                            } = &v11.1

            

        

            

                2637
            

            

                
            

            

                
                            {

            

        

            

                2638
            

            

                
            

            

                
                                if let &Opcode::Iconst = v14 {

            

        

            

                2639
            

            

                
            

            

                
                                    let v44 = C::fits_in_64(ctx, v2.0);

            

        

            

                2640
            

            

                
            

            

                
                                    if let Some(v45) = v44 {

            

        

            

                2641
            

            

                
            

            

                
                                        let v18 = C::inst_data_etor(ctx, v7.0);

            

        

            

                2642
            

            

                
            

            

                
                                        let mut v18 = v18;

            

        

            

                2643
            

            

                
            

            

                
                                        while let Some(v19) = v18.next(ctx) {

            

        

            

                2644
            

            

                
            

            

                
                                            match &v19.1 {

            

        

            

                2645
            

            

                
            

            

                
                                                &InstructionData::Binary {

            

        

            

                2646
            

            

                
            

            

                
                                                    opcode: ref v123,

            

        

            

                2647
            

            

                
            

            

                
                                                    args: ref v124,

            

        

            

                2648
            

            

                
            

            

                
                                                } => {

            

        

            

                2649
            

            

                
            

            

                
                                                    match v123 {

            

        

            

                2650
            

            

                
            

            

                
                                                        &Opcode::Ushr => {

            

        

            

                2651
            

            

                
            

            

                
                                                            if v19.0 == v45 {

            

        

            

                2652
            

            

                
            

            

                
                                                                let v125 = C::unpack_value_array_2(

            

        

            

                2653
            

            

                
            

            

                
                                                                    ctx, v124,

            

        

            

                2654
            

            

                
            

            

                
                                                                );

            

        

            

                2655
            

            

                
            

            

                
                                                                let v135 =

            

        

            

                2656
            

            

                
            

            

                
                                                                    C::inst_data_etor(ctx, v125.1);

            

        

            

                2657
            

            

                
            

            

                
                                                                let mut v135 = v135;

            

        

            

                2658
            

            

                
            

            

                
                                                                while let Some(v136) =

            

        

            

                2659
            

            

                
            

            

                
                                                                    v135.next(ctx)

            

        

            

                2660
            

            

                
            

            

                
                                                                {

            

        

            

                2661
            

            

                
            

            

                
                                                                    if let &InstructionData::UnaryImm {

            

        

            

                2662
            

            

                
            

            

                
                                                                        opcode: ref v139,

            

        

            

                2663
            

            

                
            

            

                
                                                                        imm: v140,

            

        

            

                2664
            

            

                
            

            

                
                                                                    } = &v136.1 {

            

        

            

                2665
            

            

                
            

            

                
                                                                        if let &Opcode::Iconst = v139 {

            

        

            

                2666
            

            

                
            

            

                
                                                                            if v15 == v140 {

            

        

            

                2667
            

            

                
            

            

                
                                                                                let v457 = C::imm64(ctx, 0xFFFFFFFFFFFFFFFF);

            

        

            

                2668
            

            

                
            

            

                
                                                                                let v458 = C::imm64_shl(ctx, v45, v457, v140);

            

        

            

                2669
            

            

                
            

            

                
                                                                                let v459 = constructor_iconst(ctx, v45, v458);

            

        

            

                2670
            

            

                
            

            

                
                                                                                let v460 = constructor_band(ctx, v45, v125.0, v459);

            

        

            

                2671
            

            

                
            

            

                
                                                                                // Rule at src/opts/shifts.isle line 27.

            

        

            

                2672
            

            

                
            

            

                
                                                                                returns.push(v460);

            

        

            

                2673
            

            

                
            

            

                
                                                                            }

            

        

            

                2674
            

            

                
            

            

                
                                                                        }

            

        

            

                2675
            

            

                
            

            

                
                                                                    }

            

        

            

                2676
            

            

                
            

            

                
                                                                }

            

        

            

                2677
            

            

                
            

            

                
                                                            }

            

        

            

                2678
            

            

                
            

            

                
                                                        }

            

        

            

                2679
            

            

                
            

            

                
                                                        &Opcode::Sshr => {

            

        

            

                2680
            

            

                
            

            

                
                                                            if v19.0 == v45 {

            

        

            

                2681
            

            

                
            

            

                
                                                                let v125 = C::unpack_value_array_2(

            

        

            

                2682
            

            

                
            

            

                
                                                                    ctx, v124,

            

        

            

                2683
            

            

                
            

            

                
                                                                );

            

        

            

                2684
            

            

                
            

            

                
                                                                let v135 =

            

        

            

                2685
            

            

                
            

            

                
                                                                    C::inst_data_etor(ctx, v125.1);

            

        

            

                2686
            

            

                
            

            

                
                                                                let mut v135 = v135;

            

        

            

                2687
            

            

                
            

            

                
                                                                while let Some(v136) =

            

        

            

                2688
            

            

                
            

            

                
                                                                    v135.next(ctx)

            

        

            

                2689
            

            

                
            

            

                
                                                                {

            

        

            

                2690
            

            

                
            

            

                
                                                                    if let &InstructionData::UnaryImm {

            

        

            

                2691
            

            

                
            

            

                
                                                                        opcode: ref v139,

            

        

            

                2692
            

            

                
            

            

                
                                                                        imm: v140,

            

        

            

                2693
            

            

                
            

            

                
                                                                    } = &v136.1 {

            

        

            

                2694
            

            

                
            

            

                
                                                                        if let &Opcode::Iconst = v139 {

            

        

            

                2695
            

            

                
            

            

                
                                                                            if v15 == v140 {

            

        

            

                2696
            

            

                
            

            

                
                                                                                let v457 = C::imm64(ctx, 0xFFFFFFFFFFFFFFFF);

            

        

            

                2697
            

            

                
            

            

                
                                                                                let v458 = C::imm64_shl(ctx, v45, v457, v140);

            

        

            

                2698
            

            

                
            

            

                
                                                                                let v459 = constructor_iconst(ctx, v45, v458);

            

        

            

                2699
            

            

                
            

            

                
                                                                                let v460 = constructor_band(ctx, v45, v125.0, v459);

            

        

            

                2700
            

            

                
            

            

                
                                                                                // Rule at src/opts/shifts.isle line 32.

            

        

            

                2701
            

            

                
            

            

                
                                                                                returns.push(v460);

            

        

            

                2702
            

            

                
            

            

                
                                                                            }

            

        

            

                2703
            

            

                
            

            

                
                                                                        }

            

        

            

                2704
            

            

                
            

            

                
                                                                    }

            

        

            

                2705
            

            

                
            

            

                
                                                                }

            

        

            

                2706
            

            

                
            

            

                
                                                            }

            

        

            

                2707
            

            

                
            

            

                
                                                        }

            

        

            

                2708
            

            

                
            

            

                
                                                        _ => {}

            

        

            

                2709
            

            

                
            

            

                
                                                    }

            

        

            

                2710
            

            

                
            

            

                
                                                }

            

        

            

                2711
            

            

                
            

            

                
                                                &InstructionData::UnaryImm {

            

        

            

                2712
            

            

                
            

            

                
                                                    opcode: ref v22,

            

        

            

                2713
            

            

                
            

            

                
                                                    imm: v23,

            

        

            

                2714
            

            

                
            

            

                
                                                } => {

            

        

            

                2715
            

            

                
            

            

                
                                                    if let &Opcode::Iconst = v22 {

            

        

            

                2716
            

            

                
            

            

                
                                                        if v19.0 == v45 {

            

        

            

                2717
            

            

                
            

            

                
                                                            let v229 =

            

        

            

                2718
            

            

                
            

            

                
                                                                C::imm64_shl(ctx, v45, v23, v15);

            

        

            

                2719
            

            

                
            

            

                
                                                            let v230 =

            

        

            

                2720
            

            

                
            

            

                
                                                                constructor_iconst(ctx, v45, v229);

            

        

            

                2721
            

            

                
            

            

                
                                                            let v231 = C::subsume(ctx, v230);

            

        

            

                2722
            

            

                
            

            

                
                                                            // Rule at src/opts/cprop.isle line 58.

            

        

            

                2723
            

            

                
            

            

                
                                                            returns.push(v231);

            

        

            

                2724
            

            

                
            

            

                
                                                        }

            

        

            

                2725
            

            

                
            

            

                
                                                    }

            

        

            

                2726
            

            

                
            

            

                
                                                }

            

        

            

                2727
            

            

                
            

            

                
                                                _ => {}

            

        

            

                2728
            

            

                
            

            

                
                                            }

            

        

            

                2729
            

            

                
            

            

                
                                        }

            

        

            

                2730
            

            

                
            

            

                
                                    }

            

        

            

                2731
            

            

                
            

            

                
                                    let v16 = C::u64_from_imm64(ctx, v15);

            

        

            

                2732
            

            

                
            

            

                
                                    if v16 == 0x0 {

            

        

            

                2733
            

            

                
            

            

                
                                        if v2.0 == v11.0 {

            

        

            

                2734
            

            

                
            

            

                
                                            let v17 = C::subsume(ctx, v7.0);

            

        

            

                2735
            

            

                
            

            

                
                                            // Rule at src/opts/shifts.isle line 4.

            

        

            

                2736
            

            

                
            

            

                
                                            returns.push(v17);

            

        

            

                2737
            

            

                
            

            

                
                                        }

            

        

            

                2738
            

            

                
            

            

                
                                    }

            

        

            

                2739
            

            

                
            

            

                
                                }

            

        

            

                2740
            

            

                
            

            

                
                            }

            

        

            

                2741
            

            

                
            

            

                
                        }

            

        

            

                2742
            

            

                
            

            

                
                        let v18 = C::inst_data_etor(ctx, v7.0);

            

        

            

                2743
            

            

                
            

            

                
                        let mut v18 = v18;

            

        

            

                2744
            

            

                
            

            

                
                        while let Some(v19) = v18.next(ctx) {

            

        

            

                2745
            

            

                
            

            

                
                            if let &InstructionData::Unary {

            

        

            

                2746
            

            

                
            

            

                
                                opcode: ref v36,

            

        

            

                2747
            

            

                
            

            

                
                                arg: v37,

            

        

            

                2748
            

            

                
            

            

                
                            } = &v19.1

            

        

            

                2749
            

            

                
            

            

                
                            {

            

        

            

                2750
            

            

                
            

            

                
                                if let &Opcode::Splat = v36 {

            

        

            

                2751
            

            

                
            

            

                
                                    if v2.0 == v19.0 {

            

        

            

                2752
            

            

                
            

            

                
                                        let v481 = C::lane_type(ctx, v2.0);

            

        

            

                2753
            

            

                
            

            

                
                                        let v524 = constructor_ishl(ctx, v481, v37, v7.1);

            

        

            

                2754
            

            

                
            

            

                
                                        let v525 = constructor_splat(ctx, v2.0, v524);

            

        

            

                2755
            

            

                
            

            

                
                                        // Rule at src/opts/vector.isle line 74.

            

        

            

                2756
            

            

                
            

            

                
                                        returns.push(v525);

            

        

            

                2757
            

            

                
            

            

                
                                    }

            

        

            

                2758
            

            

                
            

            

                
                                }

            

        

            

                2759
            

            

                
            

            

                
                            }

            

        

            

                2760
            

            

                
            

            

                
                        }

            

        

            

                2761
            

            

                
            

            

                
                    }

            

        

            

                2762
            

            

                
            

            

                
                    &Opcode::Ushr => {

            

        

            

                2763
            

            

                
            

            

                
                        let v7 = C::unpack_value_array_2(ctx, v6);

            

        

            

                2764
            

            

                
            

            

                
                        let v10 = C::inst_data_etor(ctx, v7.1);

            

        

            

                2765
            

            

                
            

            

                
                        let mut v10 = v10;

            

        

            

                2766
            

            

                
            

            

                
                        while let Some(v11) = v10.next(ctx) {

            

        

            

                2767
            

            

                
            

            

                
                            if let &InstructionData::UnaryImm {

            

        

            

                2768
            

            

                
            

            

                
                                opcode: ref v14,

            

        

            

                2769
            

            

                
            

            

                
                                imm: v15,

            

        

            

                2770
            

            

                
            

            

                
                            } = &v11.1

            

        

            

                2771
            

            

                
            

            

                
                            {

            

        

            

                2772
            

            

                
            

            

                
                                if let &Opcode::Iconst = v14 {

            

        

            

                2773
            

            

                
            

            

                
                                    let v18 = C::inst_data_etor(ctx, v7.0);

            

        

            

                2774
            

            

                
            

            

                
                                    let mut v18 = v18;

            

        

            

                2775
            

            

                
            

            

                
                                    while let Some(v19) = v18.next(ctx) {

            

        

            

                2776
            

            

                
            

            

                
                                        match &v19.1 {

            

        

            

                2777
            

            

                
            

            

                
                                            &InstructionData::Binary {

            

        

            

                2778
            

            

                
            

            

                
                                                opcode: ref v123,

            

        

            

                2779
            

            

                
            

            

                
                                                args: ref v124,

            

        

            

                2780
            

            

                
            

            

                
                                            } => {

            

        

            

                2781
            

            

                
            

            

                
                                                if let &Opcode::Ishl = v123 {

            

        

            

                2782
            

            

                
            

            

                
                                                    let v125 = C::unpack_value_array_2(ctx, v124);

            

        

            

                2783
            

            

                
            

            

                
                                                    let v135 = C::inst_data_etor(ctx, v125.1);

            

        

            

                2784
            

            

                
            

            

                
                                                    let mut v135 = v135;

            

        

            

                2785
            

            

                
            

            

                
                                                    while let Some(v136) = v135.next(ctx) {

            

        

            

                2786
            

            

                
            

            

                
                                                        if let &InstructionData::UnaryImm {

            

        

            

                2787
            

            

                
            

            

                
                                                            opcode: ref v139,

            

        

            

                2788
            

            

                
            

            

                
                                                            imm: v140,

            

        

            

                2789
            

            

                
            

            

                
                                                        } = &v136.1

            

        

            

                2790
            

            

                
            

            

                
                                                        {

            

        

            

                2791
            

            

                
            

            

                
                                                            if let &Opcode::Iconst = v139 {

            

        

            

                2792
            

            

                
            

            

                
                                                                if v15 == v140 {

            

        

            

                2793
            

            

                
            

            

                
                                                                    let v44 =

            

        

            

                2794
            

            

                
            

            

                
                                                                        C::fits_in_64(ctx, v2.0);

            

        

            

                2795
            

            

                
            

            

                
                                                                    if let Some(v45) = v44 {

            

        

            

                2796
            

            

                
            

            

                
                                                                        let v46 =

            

        

            

                2797
            

            

                
            

            

                
                                                                            C::ty_int(ctx, v45);

            

        

            

                2798
            

            

                
            

            

                
                                                                        if let Some(v47) = v46 {

            

        

            

                2799
            

            

                
            

            

                
                                                                            if v19.0 == v47 {

            

        

            

                2800
            

            

                
            

            

                
                                                                                let v115 =

            

        

            

                2801
            

            

                
            

            

                
                                                                                    C::ty_mask(

            

        

            

                2802
            

            

                
            

            

                
                                                                                        ctx, v47,

            

        

            

                2803
            

            

                
            

            

                
                                                                                    );

            

        

            

                2804
            

            

                
            

            

                
                                                                                let v116 = C::imm64(

            

        

            

                2805
            

            

                
            

            

                
                                                                                    ctx, v115,

            

        

            

                2806
            

            

                
            

            

                
                                                                                );

            

        

            

                2807
            

            

                
            

            

                
                                                                                let v461 =

            

        

            

                2808
            

            

                
            

            

                
                                                                                    C::imm64_ushr(

            

        

            

                2809
            

            

                
            

            

                
                                                                                        ctx, v47,

            

        

            

                2810
            

            

                
            

            

                
                                                                                        v116, v140,

            

        

            

                2811
            

            

                
            

            

                
                                                                                    );

            

        

            

                2812
            

            

                
            

            

                
                                                                                let v462 = constructor_iconst(ctx, v47, v461);

            

        

            

                2813
            

            

                
            

            

                
                                                                                let v463 = constructor_band(ctx, v47, v125.0, v462);

            

        

            

                2814
            

            

                
            

            

                
                                                                                // Rule at src/opts/shifts.isle line 41.

            

        

            

                2815
            

            

                
            

            

                
                                                                                returns.push(v463);

            

        

            

                2816
            

            

                
            

            

                
                                                                            }

            

        

            

                2817
            

            

                
            

            

                
                                                                        }

            

        

            

                2818
            

            

                
            

            

                
                                                                    }

            

        

            

                2819
            

            

                
            

            

                
                                                                    let v141 = C::u64_from_imm64(

            

        

            

                2820
            

            

                
            

            

                
                                                                        ctx, v140,

            

        

            

                2821
            

            

                
            

            

                
                                                                    );

            

        

            

                2822
            

            

                
            

            

                
                                                                    let v472 =

            

        

            

                2823
            

            

                
            

            

                
                                                                        C::u64_is_zero(ctx, v141);

            

        

            

                2824
            

            

                
            

            

                
                                                                    if v472 == false {

            

        

            

                2825
            

            

                
            

            

                
                                                                        let v150 =

            

        

            

                2826
            

            

                
            

            

                
                                                                            C::ty_bits(ctx, v2.0);

            

        

            

                2827
            

            

                
            

            

                
                                                                        let v151 =

            

        

            

                2828
            

            

                
            

            

                
                                                                            C::u8_as_u64(ctx, v150);

            

        

            

                2829
            

            

                
            

            

                
                                                                        let v473 = C::u64_sub(

            

        

            

                2830
            

            

                
            

            

                
                                                                            ctx, v151, v141,

            

        

            

                2831
            

            

                
            

            

                
                                                                        );

            

        

            

                2832
            

            

                
            

            

                
                                                                        let v474 = constructor_shift_amt_to_type(ctx, v473);

            

        

            

                2833
            

            

                
            

            

                
                                                                        if let Some(v475) = v474 {

            

        

            

                2834
            

            

                
            

            

                
                                                                            if v2.0 == v19.0 {

            

        

            

                2835
            

            

                
            

            

                
                                                                                let v476 = constructor_ireduce(ctx, v475, v125.0);

            

        

            

                2836
            

            

                
            

            

                
                                                                                let v478 = constructor_uextend(ctx, v2.0, v476);

            

        

            

                2837
            

            

                
            

            

                
                                                                                // Rule at src/opts/shifts.isle line 91.

            

        

            

                2838
            

            

                
            

            

                
                                                                                returns.push(v478);

            

        

            

                2839
            

            

                
            

            

                
                                                                            }

            

        

            

                2840
            

            

                
            

            

                
                                                                        }

            

        

            

                2841
            

            

                
            

            

                
                                                                    }

            

        

            

                2842
            

            

                
            

            

                
                                                                }

            

        

            

                2843
            

            

                
            

            

                
                                                            }

            

        

            

                2844
            

            

                
            

            

                
                                                        }

            

        

            

                2845
            

            

                
            

            

                
                                                    }

            

        

            

                2846
            

            

                
            

            

                
                                                }

            

        

            

                2847
            

            

                
            

            

                
                                            }

            

        

            

                2848
            

            

                
            

            

                
                                            &InstructionData::UnaryImm {

            

        

            

                2849
            

            

                
            

            

                
                                                opcode: ref v22,

            

        

            

                2850
            

            

                
            

            

                
                                                imm: v23,

            

        

            

                2851
            

            

                
            

            

                
                                            } => {

            

        

            

                2852
            

            

                
            

            

                
                                                if let &Opcode::Iconst = v22 {

            

        

            

                2853
            

            

                
            

            

                
                                                    let v44 = C::fits_in_64(ctx, v2.0);

            

        

            

                2854
            

            

                
            

            

                
                                                    if let Some(v45) = v44 {

            

        

            

                2855
            

            

                
            

            

                
                                                        if v19.0 == v45 {

            

        

            

                2856
            

            

                
            

            

                
                                                            let v232 =

            

        

            

                2857
            

            

                
            

            

                
                                                                C::imm64_ushr(ctx, v45, v23, v15);

            

        

            

                2858
            

            

                
            

            

                
                                                            let v233 =

            

        

            

                2859
            

            

                
            

            

                
                                                                constructor_iconst(ctx, v45, v232);

            

        

            

                2860
            

            

                
            

            

                
                                                            let v234 = C::subsume(ctx, v233);

            

        

            

                2861
            

            

                
            

            

                
                                                            // Rule at src/opts/cprop.isle line 63.

            

        

            

                2862
            

            

                
            

            

                
                                                            returns.push(v234);

            

        

            

                2863
            

            

                
            

            

                
                                                        }

            

        

            

                2864
            

            

                
            

            

                
                                                    }

            

        

            

                2865
            

            

                
            

            

                
                                                }

            

        

            

                2866
            

            

                
            

            

                
                                            }

            

        

            

                2867
            

            

                
            

            

                
                                            _ => {}

            

        

            

                2868
            

            

                
            

            

                
                                        }

            

        

            

                2869
            

            

                
            

            

                
                                    }

            

        

            

                2870
            

            

                
            

            

                
                                    let v16 = C::u64_from_imm64(ctx, v15);

            

        

            

                2871
            

            

                
            

            

                
                                    if v16 == 0x0 {

            

        

            

                2872
            

            

                
            

            

                
                                        if v2.0 == v11.0 {

            

        

            

                2873
            

            

                
            

            

                
                                            let v17 = C::subsume(ctx, v7.0);

            

        

            

                2874
            

            

                
            

            

                
                                            // Rule at src/opts/shifts.isle line 8.

            

        

            

                2875
            

            

                
            

            

                
                                            returns.push(v17);

            

        

            

                2876
            

            

                
            

            

                
                                        }

            

        

            

                2877
            

            

                
            

            

                
                                    }

            

        

            

                2878
            

            

                
            

            

                
                                }

            

        

            

                2879
            

            

                
            

            

                
                            }

            

        

            

                2880
            

            

                
            

            

                
                        }

            

        

            

                2881
            

            

                
            

            

                
                        let v18 = C::inst_data_etor(ctx, v7.0);

            

        

            

                2882
            

            

                
            

            

                
                        let mut v18 = v18;

            

        

            

                2883
            

            

                
            

            

                
                        while let Some(v19) = v18.next(ctx) {

            

        

            

                2884
            

            

                
            

            

                
                            if let &InstructionData::Unary {

            

        

            

                2885
            

            

                
            

            

                
                                opcode: ref v36,

            

        

            

                2886
            

            

                
            

            

                
                                arg: v37,

            

        

            

                2887
            

            

                
            

            

                
                            } = &v19.1

            

        

            

                2888
            

            

                
            

            

                
                            {

            

        

            

                2889
            

            

                
            

            

                
                                if let &Opcode::Splat = v36 {

            

        

            

                2890
            

            

                
            

            

                
                                    if v2.0 == v19.0 {

            

        

            

                2891
            

            

                
            

            

                
                                        let v481 = C::lane_type(ctx, v2.0);

            

        

            

                2892
            

            

                
            

            

                
                                        let v526 = constructor_ushr(ctx, v481, v37, v7.1);

            

        

            

                2893
            

            

                
            

            

                
                                        let v527 = constructor_splat(ctx, v2.0, v526);

            

        

            

                2894
            

            

                
            

            

                
                                        // Rule at src/opts/vector.isle line 77.

            

        

            

                2895
            

            

                
            

            

                
                                        returns.push(v527);

            

        

            

                2896
            

            

                
            

            

                
                                    }

            

        

            

                2897
            

            

                
            

            

                
                                }

            

        

            

                2898
            

            

                
            

            

                
                            }

            

        

            

                2899
            

            

                
            

            

                
                        }

            

        

            

                2900
            

            

                
            

            

                
                    }

            

        

            

                2901
            

            

                
            

            

                
                    &Opcode::Sshr => {

            

        

            

                2902
            

            

                
            

            

                
                        let v7 = C::unpack_value_array_2(ctx, v6);

            

        

            

                2903
            

            

                
            

            

                
                        let v10 = C::inst_data_etor(ctx, v7.1);

            

        

            

                2904
            

            

                
            

            

                
                        let mut v10 = v10;

            

        

            

                2905
            

            

                
            

            

                
                        while let Some(v11) = v10.next(ctx) {

            

        

            

                2906
            

            

                
            

            

                
                            if let &InstructionData::UnaryImm {

            

        

            

                2907
            

            

                
            

            

                
                                opcode: ref v14,

            

        

            

                2908
            

            

                
            

            

                
                                imm: v15,

            

        

            

                2909
            

            

                
            

            

                
                            } = &v11.1

            

        

            

                2910
            

            

                
            

            

                
                            {

            

        

            

                2911
            

            

                
            

            

                
                                if let &Opcode::Iconst = v14 {

            

        

            

                2912
            

            

                
            

            

                
                                    let v18 = C::inst_data_etor(ctx, v7.0);

            

        

            

                2913
            

            

                
            

            

                
                                    let mut v18 = v18;

            

        

            

                2914
            

            

                
            

            

                
                                    while let Some(v19) = v18.next(ctx) {

            

        

            

                2915
            

            

                
            

            

                
                                        match &v19.1 {

            

        

            

                2916
            

            

                
            

            

                
                                            &InstructionData::Binary {

            

        

            

                2917
            

            

                
            

            

                
                                                opcode: ref v123,

            

        

            

                2918
            

            

                
            

            

                
                                                args: ref v124,

            

        

            

                2919
            

            

                
            

            

                
                                            } => {

            

        

            

                2920
            

            

                
            

            

                
                                                match v123 {

            

        

            

                2921
            

            

                
            

            

                
                                                    &Opcode::Bor => {

            

        

            

                2922
            

            

                
            

            

                
                                                        let v16 = C::u64_from_imm64(ctx, v15);

            

        

            

                2923
            

            

                
            

            

                
                                                        let v150 = C::ty_bits(ctx, v2.0);

            

        

            

                2924
            

            

                
            

            

                
                                                        let v151 = C::u8_as_u64(ctx, v150);

            

        

            

                2925
            

            

                
            

            

                
                                                        let v153 = C::u64_sub(ctx, v151, 0x1);

            

        

            

                2926
            

            

                
            

            

                
                                                        let v154 = C::u64_eq(ctx, v16, v153);

            

        

            

                2927
            

            

                
            

            

                
                                                        if v154 == true {

            

        

            

                2928
            

            

                
            

            

                
                                                            if v2.0 == v11.0 {

            

        

            

                2929
            

            

                
            

            

                
                                                                if v2.0 == v19.0 {

            

        

            

                2930
            

            

                
            

            

                
                                                                    let v125 =

            

        

            

                2931
            

            

                
            

            

                
                                                                        C::unpack_value_array_2(

            

        

            

                2932
            

            

                
            

            

                
                                                                            ctx, v124,

            

        

            

                2933
            

            

                
            

            

                
                                                                        );

            

        

            

                2934
            

            

                
            

            

                
                                                                    let v135 = C::inst_data_etor(

            

        

            

                2935
            

            

                
            

            

                
                                                                        ctx, v125.1,

            

        

            

                2936
            

            

                
            

            

                
                                                                    );

            

        

            

                2937
            

            

                
            

            

                
                                                                    let mut v135 = v135;

            

        

            

                2938
            

            

                
            

            

                
                                                                    while let Some(v136) =

            

        

            

                2939
            

            

                
            

            

                
                                                                        v135.next(ctx)

            

        

            

                2940
            

            

                
            

            

                
                                                                    {

            

        

            

                2941
            

            

                
            

            

                
                                                                        if let &InstructionData::Unary {

            

        

            

                2942
            

            

                
            

            

                
                                                                            opcode: ref v148,

            

        

            

                2943
            

            

                
            

            

                
                                                                            arg: v149,

            

        

            

                2944
            

            

                
            

            

                
                                                                        } = &v136.1 {

            

        

            

                2945
            

            

                
            

            

                
                                                                            if let &Opcode::Ineg = v148 {

            

        

            

                2946
            

            

                
            

            

                
                                                                                if v2.0 == v136.0 {

            

        

            

                2947
            

            

                
            

            

                
                                                                                    if v125.0 == v149 {

            

        

            

                2948
            

            

                
            

            

                
                                                                                        let v155 = constructor_bmask(ctx, v2.0, v125.0);

            

        

            

                2949
            

            

                
            

            

                
                                                                                        // Rule at src/opts/bitops.isle line 100.

            

        

            

                2950
            

            

                
            

            

                
                                                                                        returns.push(v155);

            

        

            

                2951
            

            

                
            

            

                
                                                                                    }

            

        

            

                2952
            

            

                
            

            

                
                                                                                }

            

        

            

                2953
            

            

                
            

            

                
                                                                            }

            

        

            

                2954
            

            

                
            

            

                
                                                                        }

            

        

            

                2955
            

            

                
            

            

                
                                                                    }

            

        

            

                2956
            

            

                
            

            

                
                                                                    let v156 = C::inst_data_etor(

            

        

            

                2957
            

            

                
            

            

                
                                                                        ctx, v125.0,

            

        

            

                2958
            

            

                
            

            

                
                                                                    );

            

        

            

                2959
            

            

                
            

            

                
                                                                    let mut v156 = v156;

            

        

            

                2960
            

            

                
            

            

                
                                                                    while let Some(v157) =

            

        

            

                2961
            

            

                
            

            

                
                                                                        v156.next(ctx)

            

        

            

                2962
            

            

                
            

            

                
                                                                    {

            

        

            

                2963
            

            

                
            

            

                
                                                                        if let &InstructionData::Unary {

            

        

            

                2964
            

            

                
            

            

                
                                                                            opcode: ref v160,

            

        

            

                2965
            

            

                
            

            

                
                                                                            arg: v161,

            

        

            

                2966
            

            

                
            

            

                
                                                                        } = &v157.1 {

            

        

            

                2967
            

            

                
            

            

                
                                                                            if let &Opcode::Ineg = v160 {

            

        

            

                2968
            

            

                
            

            

                
                                                                                if v125.1 == v161 {

            

        

            

                2969
            

            

                
            

            

                
                                                                                    if v2.0 == v157.0 {

            

        

            

                2970
            

            

                
            

            

                
                                                                                        let v162 = constructor_bmask(ctx, v2.0, v161);

            

        

            

                2971
            

            

                
            

            

                
                                                                                        // Rule at src/opts/bitops.isle line 104.

            

        

            

                2972
            

            

                
            

            

                
                                                                                        returns.push(v162);

            

        

            

                2973
            

            

                
            

            

                
                                                                                    }

            

        

            

                2974
            

            

                
            

            

                
                                                                                }

            

        

            

                2975
            

            

                
            

            

                
                                                                            }

            

        

            

                2976
            

            

                
            

            

                
                                                                        }

            

        

            

                2977
            

            

                
            

            

                
                                                                    }

            

        

            

                2978
            

            

                
            

            

                
                                                                }

            

        

            

                2979
            

            

                
            

            

                
                                                            }

            

        

            

                2980
            

            

                
            

            

                
                                                        }

            

        

            

                2981
            

            

                
            

            

                
                                                    }

            

        

            

                2982
            

            

                
            

            

                
                                                    &Opcode::Ishl => {

            

        

            

                2983
            

            

                
            

            

                
                                                        if v2.0 == v19.0 {

            

        

            

                2984
            

            

                
            

            

                
                                                            let v125 =

            

        

            

                2985
            

            

                
            

            

                
                                                                C::unpack_value_array_2(ctx, v124);

            

        

            

                2986
            

            

                
            

            

                
                                                            let v135 =

            

        

            

                2987
            

            

                
            

            

                
                                                                C::inst_data_etor(ctx, v125.1);

            

        

            

                2988
            

            

                
            

            

                
                                                            let mut v135 = v135;

            

        

            

                2989
            

            

                
            

            

                
                                                            while let Some(v136) = v135.next(ctx) {

            

        

            

                2990
            

            

                
            

            

                
                                                                if let &InstructionData::UnaryImm {

            

        

            

                2991
            

            

                
            

            

                
                                                                    opcode: ref v139,

            

        

            

                2992
            

            

                
            

            

                
                                                                    imm: v140,

            

        

            

                2993
            

            

                
            

            

                
                                                                } = &v136.1 {

            

        

            

                2994
            

            

                
            

            

                
                                                                    if let &Opcode::Iconst = v139 {

            

        

            

                2995
            

            

                
            

            

                
                                                                        if v15 == v140 {

            

        

            

                2996
            

            

                
            

            

                
                                                                            let v156 = C::inst_data_etor(ctx, v125.0);

            

        

            

                2997
            

            

                
            

            

                
                                                                            let mut v156 = v156;

            

        

            

                2998
            

            

                
            

            

                
                                                                            while let Some(v157) = v156.next(ctx) {

            

        

            

                2999
            

            

                
            

            

                
                                                                                if let &InstructionData::Unary {

            

        

            

                3000
            

            

                
            

            

                
                                                                                    opcode: ref v160,

            

        

            

                3001
            

            

                
            

            

                
                                                                                    arg: v161,

            

        

            

                3002
            

            

                
            

            

                
                                                                                } = &v157.1 {

            

        

            

                3003
            

            

                
            

            

                
                                                                                    match v160 {

            

        

            

                3004
            

            

                
            

            

                
                                                                                        &Opcode::Uextend => {

            

        

            

                3005
            

            

                
            

            

                
                                                                                            if v2.0 == v157.0 {

            

        

            

                3006
            

            

                
            

            

                
                                                                                                let v141 = C::u64_from_imm64(ctx, v140);

            

        

            

                3007
            

            

                
            

            

                
                                                                                                let v465 = C::ty_bits_u64(ctx, v2.0);

            

        

            

                3008
            

            

                
            

            

                
                                                                                                let v464 = C::value_type(ctx, v161);

            

        

            

                3009
            

            

                
            

            

                
                                                                                                let v466 = C::ty_bits_u64(ctx, v464);

            

        

            

                3010
            

            

                
            

            

                
                                                                                                let v467 = C::u64_sub(ctx, v465, v466);

            

        

            

                3011
            

            

                
            

            

                
                                                                                                let v468 = C::u64_eq(ctx, v141, v467);

            

        

            

                3012
            

            

                
            

            

                
                                                                                                if v468 == true {

            

        

            

                3013
            

            

                
            

            

                
                                                                                                    let v469 = constructor_sextend(ctx, v2.0, v161);

            

        

            

                3014
            

            

                
            

            

                
                                                                                                    // Rule at src/opts/shifts.isle line 50.

            

        

            

                3015
            

            

                
            

            

                
                                                                                                    returns.push(v469);

            

        

            

                3016
            

            

                
            

            

                
                                                                                                }

            

        

            

                3017
            

            

                
            

            

                
                                                                                                let v470 = C::u64_lt(ctx, v141, v467);

            

        

            

                3018
            

            

                
            

            

                
                                                                                                if v470 == true {

            

        

            

                3019
            

            

                
            

            

                
                                                                                                    // Rule at src/opts/shifts.isle line 62.

            

        

            

                3020
            

            

                
            

            

                
                                                                                                    returns.push(v125.0);

            

        

            

                3021
            

            

                
            

            

                
                                                                                                }

            

        

            

                3022
            

            

                
            

            

                
                                                                                            }

            

        

            

                3023
            

            

                
            

            

                
                                                                                        }

            

        

            

                3024
            

            

                
            

            

                
                                                                                        &Opcode::Sextend => {

            

        

            

                3025
            

            

                
            

            

                
                                                                                            let v141 = C::u64_from_imm64(ctx, v140);

            

        

            

                3026
            

            

                
            

            

                
                                                                                            let v465 = C::ty_bits_u64(ctx, v2.0);

            

        

            

                3027
            

            

                
            

            

                
                                                                                            let v464 = C::value_type(ctx, v161);

            

        

            

                3028
            

            

                
            

            

                
                                                                                            let v466 = C::ty_bits_u64(ctx, v464);

            

        

            

                3029
            

            

                
            

            

                
                                                                                            let v467 = C::u64_sub(ctx, v465, v466);

            

        

            

                3030
            

            

                
            

            

                
                                                                                            let v471 = C::u64_le(ctx, v141, v467);

            

        

            

                3031
            

            

                
            

            

                
                                                                                            if v471 == true {

            

        

            

                3032
            

            

                
            

            

                
                                                                                                if v2.0 == v157.0 {

            

        

            

                3033
            

            

                
            

            

                
                                                                                                    // Rule at src/opts/shifts.isle line 73.

            

        

            

                3034
            

            

                
            

            

                
                                                                                                    returns.push(v125.0);

            

        

            

                3035
            

            

                
            

            

                
                                                                                                }

            

        

            

                3036
            

            

                
            

            

                
                                                                                            }

            

        

            

                3037
            

            

                
            

            

                
                                                                                        }

            

        

            

                3038
            

            

                
            

            

                
                                                                                        _ => {}

            

        

            

                3039
            

            

                
            

            

                
                                                                                    }

            

        

            

                3040
            

            

                
            

            

                
                                                                                }

            

        

            

                3041
            

            

                
            

            

                
                                                                            }

            

        

            

                3042
            

            

                
            

            

                
                                                                            let v141 = C::u64_from_imm64(ctx, v140);

            

        

            

                3043
            

            

                
            

            

                
                                                                            let v472 = C::u64_is_zero(ctx, v141);

            

        

            

                3044
            

            

                
            

            

                
                                                                            if v472 == false {

            

        

            

                3045
            

            

                
            

            

                
                                                                                let v150 = C::ty_bits(ctx, v2.0);

            

        

            

                3046
            

            

                
            

            

                
                                                                                let v151 = C::u8_as_u64(ctx, v150);

            

        

            

                3047
            

            

                
            

            

                
                                                                                let v473 = C::u64_sub(ctx, v151, v141);

            

        

            

                3048
            

            

                
            

            

                
                                                                                let v474 = constructor_shift_amt_to_type(ctx, v473);

            

        

            

                3049
            

            

                
            

            

                
                                                                                if let Some(v475) = v474 {

            

        

            

                3050
            

            

                
            

            

                
                                                                                    let v476 = constructor_ireduce(ctx, v475, v125.0);

            

        

            

                3051
            

            

                
            

            

                
                                                                                    let v477 = constructor_sextend(ctx, v2.0, v476);

            

        

            

                3052
            

            

                
            

            

                
                                                                                    // Rule at src/opts/shifts.isle line 87.

            

        

            

                3053
            

            

                
            

            

                
                                                                                    returns.push(v477);

            

        

            

                3054
            

            

                
            

            

                
                                                                                }

            

        

            

                3055
            

            

                
            

            

                
                                                                            }

            

        

            

                3056
            

            

                
            

            

                
                                                                        }

            

        

            

                3057
            

            

                
            

            

                
                                                                    }

            

        

            

                3058
            

            

                
            

            

                
                                                                }

            

        

            

                3059
            

            

                
            

            

                
                                                            }

            

        

            

                3060
            

            

                
            

            

                
                                                        }

            

        

            

                3061
            

            

                
            

            

                
                                                    }

            

        

            

                3062
            

            

                
            

            

                
                                                    _ => {}

            

        

            

                3063
            

            

                
            

            

                
                                                }

            

        

            

                3064
            

            

                
            

            

                
                                            }

            

        

            

                3065
            

            

                
            

            

                
                                            &InstructionData::UnaryImm {

            

        

            

                3066
            

            

                
            

            

                
                                                opcode: ref v22,

            

        

            

                3067
            

            

                
            

            

                
                                                imm: v23,

            

        

            

                3068
            

            

                
            

            

                
                                            } => {

            

        

            

                3069
            

            

                
            

            

                
                                                if let &Opcode::Iconst = v22 {

            

        

            

                3070
            

            

                
            

            

                
                                                    let v44 = C::fits_in_64(ctx, v2.0);

            

        

            

                3071
            

            

                
            

            

                
                                                    if let Some(v45) = v44 {

            

        

            

                3072
            

            

                
            

            

                
                                                        if v19.0 == v45 {

            

        

            

                3073
            

            

                
            

            

                
                                                            let v235 =

            

        

            

                3074
            

            

                
            

            

                
                                                                C::imm64_sshr(ctx, v45, v23, v15);

            

        

            

                3075
            

            

                
            

            

                
                                                            let v236 =

            

        

            

                3076
            

            

                
            

            

                
                                                                constructor_iconst(ctx, v45, v235);

            

        

            

                3077
            

            

                
            

            

                
                                                            let v237 = C::subsume(ctx, v236);

            

        

            

                3078
            

            

                
            

            

                
                                                            // Rule at src/opts/cprop.isle line 68.

            

        

            

                3079
            

            

                
            

            

                
                                                            returns.push(v237);

            

        

            

                3080
            

            

                
            

            

                
                                                        }

            

        

            

                3081
            

            

                
            

            

                
                                                    }

            

        

            

                3082
            

            

                
            

            

                
                                                }

            

        

            

                3083
            

            

                
            

            

                
                                            }

            

        

            

                3084
            

            

                
            

            

                
                                            _ => {}

            

        

            

                3085
            

            

                
            

            

                
                                        }

            

        

            

                3086
            

            

                
            

            

                
                                    }

            

        

            

                3087
            

            

                
            

            

                
                                    let v16 = C::u64_from_imm64(ctx, v15);

            

        

            

                3088
            

            

                
            

            

                
                                    if v16 == 0x0 {

            

        

            

                3089
            

            

                
            

            

                
                                        if v2.0 == v11.0 {

            

        

            

                3090
            

            

                
            

            

                
                                            let v17 = C::subsume(ctx, v7.0);

            

        

            

                3091
            

            

                
            

            

                
                                            // Rule at src/opts/shifts.isle line 12.

            

        

            

                3092
            

            

                
            

            

                
                                            returns.push(v17);

            

        

            

                3093
            

            

                
            

            

                
                                        }

            

        

            

                3094
            

            

                
            

            

                
                                    }

            

        

            

                3095
            

            

                
            

            

                
                                }

            

        

            

                3096
            

            

                
            

            

                
                            }

            

        

            

                3097
            

            

                
            

            

                
                        }

            

        

            

                3098
            

            

                
            

            

                
                        let v18 = C::inst_data_etor(ctx, v7.0);

            

        

            

                3099
            

            

                
            

            

                
                        let mut v18 = v18;

            

        

            

                3100
            

            

                
            

            

                
                        while let Some(v19) = v18.next(ctx) {

            

        

            

                3101
            

            

                
            

            

                
                            if let &InstructionData::Unary {

            

        

            

                3102
            

            

                
            

            

                
                                opcode: ref v36,

            

        

            

                3103
            

            

                
            

            

                
                                arg: v37,

            

        

            

                3104
            

            

                
            

            

                
                            } = &v19.1

            

        

            

                3105
            

            

                
            

            

                
                            {

            

        

            

                3106
            

            

                
            

            

                
                                if let &Opcode::Splat = v36 {

            

        

            

                3107
            

            

                
            

            

                
                                    if v2.0 == v19.0 {

            

        

            

                3108
            

            

                
            

            

                
                                        let v481 = C::lane_type(ctx, v2.0);

            

        

            

                3109
            

            

                
            

            

                
                                        let v528 = constructor_sshr(ctx, v481, v37, v7.1);

            

        

            

                3110
            

            

                
            

            

                
                                        let v529 = constructor_splat(ctx, v2.0, v528);

            

        

            

                3111
            

            

                
            

            

                
                                        // Rule at src/opts/vector.isle line 80.

            

        

            

                3112
            

            

                
            

            

                
                                        returns.push(v529);

            

        

            

                3113
            

            

                
            

            

                
                                    }

            

        

            

                3114
            

            

                
            

            

                
                                }

            

        

            

                3115
            

            

                
            

            

                
                            }

            

        

            

                3116
            

            

                
            

            

                
                        }

            

        

            

                3117
            

            

                
            

            

                
                    }

            

        

            

                3118
            

            

                
            

            

                
                    &Opcode::Fmul => {

            

        

            

                3119
            

            

                
            

            

                
                        let v7 = C::unpack_value_array_2(ctx, v6);

            

        

            

                3120
            

            

                
            

            

                
                        let v10 = C::inst_data_etor(ctx, v7.1);

            

        

            

                3121
            

            

                
            

            

                
                        let mut v10 = v10;

            

        

            

                3122
            

            

                
            

            

                
                        while let Some(v11) = v10.next(ctx) {

            

        

            

                3123
            

            

                
            

            

                
                            if let &InstructionData::Unary {

            

        

            

                3124
            

            

                
            

            

                
                                opcode: ref v38,

            

        

            

                3125
            

            

                
            

            

                
                                arg: v39,

            

        

            

                3126
            

            

                
            

            

                
                            } = &v11.1

            

        

            

                3127
            

            

                
            

            

                
                            {

            

        

            

                3128
            

            

                
            

            

                
                                if let &Opcode::Fneg = v38 {

            

        

            

                3129
            

            

                
            

            

                
                                    if v2.0 == v11.0 {

            

        

            

                3130
            

            

                
            

            

                
                                        let v18 = C::inst_data_etor(ctx, v7.0);

            

        

            

                3131
            

            

                
            

            

                
                                        let mut v18 = v18;

            

        

            

                3132
            

            

                
            

            

                
                                        while let Some(v19) = v18.next(ctx) {

            

        

            

                3133
            

            

                
            

            

                
                                            if let &InstructionData::Unary {

            

        

            

                3134
            

            

                
            

            

                
                                                opcode: ref v36,

            

        

            

                3135
            

            

                
            

            

                
                                                arg: v37,

            

        

            

                3136
            

            

                
            

            

                
                                            } = &v19.1

            

        

            

                3137
            

            

                
            

            

                
                                            {

            

        

            

                3138
            

            

                
            

            

                
                                                if let &Opcode::Fneg = v36 {

            

        

            

                3139
            

            

                
            

            

                
                                                    if v2.0 == v19.0 {

            

        

            

                3140
            

            

                
            

            

                
                                                        let v114 =

            

        

            

                3141
            

            

                
            

            

                
                                                            constructor_fmul(ctx, v2.0, v37, v39);

            

        

            

                3142
            

            

                
            

            

                
                                                        // Rule at src/opts/arithmetic.isle line 127.

            

        

            

                3143
            

            

                
            

            

                
                                                        returns.push(v114);

            

        

            

                3144
            

            

                
            

            

                
                                                    }

            

        

            

                3145
            

            

                
            

            

                
                                                }

            

        

            

                3146
            

            

                
            

            

                
                                            }

            

        

            

                3147
            

            

                
            

            

                
                                        }

            

        

            

                3148
            

            

                
            

            

                
                                    }

            

        

            

                3149
            

            

                
            

            

                
                                }

            

        

            

                3150
            

            

                
            

            

                
                            }

            

        

            

                3151
            

            

                
            

            

                
                        }

            

        

            

                3152
            

            

                
            

            

                
                    }

            

        

            

                3153
            

            

                
            

            

                
                    _ => {}

            

        

            

                3154
            

            

                
            

            

                
                }

            

        

            

                3155
            

            

                
            

            

                
            }

            

        

            

                3156
            

            

                
            

            

                
            &InstructionData::IntCompare {

            

        

            

                3157
            

            

                
            

            

                
                opcode: ref v169,

            

        

            

                3158
            

            

                
            

            

                
                args: ref v170,

            

        

            

                3159
            

            

                
            

            

                
                cond: ref v171,

            

        

            

                3160
            

            

                
            

            

                
            } => {

            

        

            

                3161
            

            

                
            

            

                
                if let &Opcode::Icmp = v169 {

            

        

            

                3162
            

            

                
            

            

                
                    match v171 {

            

        

            

                3163
            

            

                
            

            

                
                        &IntCC::Equal => {

            

        

            

                3164
            

            

                
            

            

                
                            let v44 = C::fits_in_64(ctx, v2.0);

            

        

            

                3165
            

            

                
            

            

                
                            if let Some(v45) = v44 {

            

        

            

                3166
            

            

                
            

            

                
                                let v46 = C::ty_int(ctx, v45);

            

        

            

                3167
            

            

                
            

            

                
                                if let Some(v47) = v46 {

            

        

            

                3168
            

            

                
            

            

                
                                    let v172 = C::unpack_value_array_2(ctx, v170);

            

        

            

                3169
            

            

                
            

            

                
                                    if v172.0 == v172.1 {

            

        

            

                3170
            

            

                
            

            

                
                                        let v343 = C::imm64(ctx, 0x1);

            

        

            

                3171
            

            

                
            

            

                
                                        let v346 = constructor_iconst(ctx, v47, v343);

            

        

            

                3172
            

            

                
            

            

                
                                        // Rule at src/opts/icmp.isle line 5.

            

        

            

                3173
            

            

                
            

            

                
                                        returns.push(v346);

            

        

            

                3174
            

            

                
            

            

                
                                    }

            

        

            

                3175
            

            

                
            

            

                
                                }

            

        

            

                3176
            

            

                
            

            

                
                            }

            

        

            

                3177
            

            

                
            

            

                
                            let v172 = C::unpack_value_array_2(ctx, v170);

            

        

            

                3178
            

            

                
            

            

                
                            let v175 = C::inst_data_etor(ctx, v172.1);

            

        

            

                3179
            

            

                
            

            

                
                            let mut v175 = v175;

            

        

            

                3180
            

            

                
            

            

                
                            while let Some(v176) = v175.next(ctx) {

            

        

            

                3181
            

            

                
            

            

                
                                if let &InstructionData::UnaryImm {

            

        

            

                3182
            

            

                
            

            

                
                                    opcode: ref v179,

            

        

            

                3183
            

            

                
            

            

                
                                    imm: v180,

            

        

            

                3184
            

            

                
            

            

                
                                } = &v176.1

            

        

            

                3185
            

            

                
            

            

                
                                {

            

        

            

                3186
            

            

                
            

            

                
                                    if let &Opcode::Iconst = v179 {

            

        

            

                3187
            

            

                
            

            

                
                                        let v181 = C::u64_from_imm64(ctx, v180);

            

        

            

                3188
            

            

                
            

            

                
                                        if v181 == 0x0 {

            

        

            

                3189
            

            

                
            

            

                
                                            let v252 = C::inst_data_etor(ctx, v172.0);

            

        

            

                3190
            

            

                
            

            

                
                                            let mut v252 = v252;

            

        

            

                3191
            

            

                
            

            

                
                                            while let Some(v253) = v252.next(ctx) {

            

        

            

                3192
            

            

                
            

            

                
                                                if let &InstructionData::Unary {

            

        

            

                3193
            

            

                
            

            

                
                                                    opcode: ref v339,

            

        

            

                3194
            

            

                
            

            

                
                                                    arg: v340,

            

        

            

                3195
            

            

                
            

            

                
                                                } = &v253.1

            

        

            

                3196
            

            

                
            

            

                
                                                {

            

        

            

                3197
            

            

                
            

            

                
                                                    if let &Opcode::Uextend = v339 {

            

        

            

                3198
            

            

                
            

            

                
                                                        let v347 = C::inst_data_etor(ctx, v340);

            

        

            

                3199
            

            

                
            

            

                
                                                        let mut v347 = v347;

            

        

            

                3200
            

            

                
            

            

                
                                                        while let Some(v348) = v347.next(ctx) {

            

        

            

                3201
            

            

                
            

            

                
                                                            if let &InstructionData::IntCompare {

            

        

            

                3202
            

            

                
            

            

                
                                                                opcode: ref v351,

            

        

            

                3203
            

            

                
            

            

                
                                                                args: ref v352,

            

        

            

                3204
            

            

                
            

            

                
                                                                cond: ref v353,

            

        

            

                3205
            

            

                
            

            

                
                                                            } = &v348.1

            

        

            

                3206
            

            

                
            

            

                
                                                            {

            

        

            

                3207
            

            

                
            

            

                
                                                                if let &Opcode::Icmp = v351 {

            

        

            

                3208
            

            

                
            

            

                
                                                                    if v2.0 == v348.0 {

            

        

            

                3209
            

            

                
            

            

                
                                                                        let v358 =

            

        

            

                3210
            

            

                
            

            

                
                                                                            &C::intcc_complement(

            

        

            

                3211
            

            

                
            

            

                
                                                                                ctx, v353,

            

        

            

                3212
            

            

                
            

            

                
                                                                            );

            

        

            

                3213
            

            

                
            

            

                
                                                                        let v354 =

            

        

            

                3214
            

            

                
            

            

                
                                                                            C::unpack_value_array_2(

            

        

            

                3215
            

            

                
            

            

                
                                                                                ctx, v352,

            

        

            

                3216
            

            

                
            

            

                
                                                                            );

            

        

            

                3217
            

            

                
            

            

                
                                                                        let v359 = constructor_icmp(

            

        

            

                3218
            

            

                
            

            

                
                                                                            ctx, v2.0, v358,

            

        

            

                3219
            

            

                
            

            

                
                                                                            v354.0, v354.1,

            

        

            

                3220
            

            

                
            

            

                
                                                                        );

            

        

            

                3221
            

            

                
            

            

                
                                                                        let v360 =

            

        

            

                3222
            

            

                
            

            

                
                                                                            C::subsume(ctx, v359);

            

        

            

                3223
            

            

                
            

            

                
                                                                        // Rule at src/opts/icmp.isle line 22.

            

        

            

                3224
            

            

                
            

            

                
                                                                        returns.push(v360);

            

        

            

                3225
            

            

                
            

            

                
                                                                    }

            

        

            

                3226
            

            

                
            

            

                
                                                                }

            

        

            

                3227
            

            

                
            

            

                
                                                            }

            

        

            

                3228
            

            

                
            

            

                
                                                        }

            

        

            

                3229
            

            

                
            

            

                
                                                    }

            

        

            

                3230
            

            

                
            

            

                
                                                }

            

        

            

                3231
            

            

                
            

            

                
                                            }

            

        

            

                3232
            

            

                
            

            

                
                                        }

            

        

            

                3233
            

            

                
            

            

                
                                    }

            

        

            

                3234
            

            

                
            

            

                
                                }

            

        

            

                3235
            

            

                
            

            

                
                            }

            

        

            

                3236
            

            

                
            

            

                
                        }

            

        

            

                3237
            

            

                
            

            

                
                        &IntCC::NotEqual => {

            

        

            

                3238
            

            

                
            

            

                
                            let v172 = C::unpack_value_array_2(ctx, v170);

            

        

            

                3239
            

            

                
            

            

                
                            let v175 = C::inst_data_etor(ctx, v172.1);

            

        

            

                3240
            

            

                
            

            

                
                            let mut v175 = v175;

            

        

            

                3241
            

            

                
            

            

                
                            while let Some(v176) = v175.next(ctx) {

            

        

            

                3242
            

            

                
            

            

                
                                if let &InstructionData::UnaryImm {

            

        

            

                3243
            

            

                
            

            

                
                                    opcode: ref v179,

            

        

            

                3244
            

            

                
            

            

                
                                    imm: v180,

            

        

            

                3245
            

            

                
            

            

                
                                } = &v176.1

            

        

            

                3246
            

            

                
            

            

                
                                {

            

        

            

                3247
            

            

                
            

            

                
                                    if let &Opcode::Iconst = v179 {

            

        

            

                3248
            

            

                
            

            

                
                                        let v181 = C::u64_from_imm64(ctx, v180);

            

        

            

                3249
            

            

                
            

            

                
                                        if v181 == 0x0 {

            

        

            

                3250
            

            

                
            

            

                
                                            let v182 = constructor_truthy(ctx, v172.0);

            

        

            

                3251
            

            

                
            

            

                
                                            let mut v182 = v182;

            

        

            

                3252
            

            

                
            

            

                
                                            while let Some(v183) = v182.next(ctx) {

            

        

            

                3253
            

            

                
            

            

                
                                                let v184 = C::value_type(ctx, v183);

            

        

            

                3254
            

            

                
            

            

                
                                                let v49 = C::imm64(ctx, 0x0);

            

        

            

                3255
            

            

                
            

            

                
                                                let v185 = constructor_iconst(ctx, v184, v49);

            

        

            

                3256
            

            

                
            

            

                
                                                let v186 = constructor_ne(ctx, v2.0, v183, v185);

            

        

            

                3257
            

            

                
            

            

                
                                                // Rule at src/opts/bitops.isle line 130.

            

        

            

                3258
            

            

                
            

            

                
                                                returns.push(v186);

            

        

            

                3259
            

            

                
            

            

                
                                            }

            

        

            

                3260
            

            

                
            

            

                
                                            let v252 = C::inst_data_etor(ctx, v172.0);

            

        

            

                3261
            

            

                
            

            

                
                                            let mut v252 = v252;

            

        

            

                3262
            

            

                
            

            

                
                                            while let Some(v253) = v252.next(ctx) {

            

        

            

                3263
            

            

                
            

            

                
                                                if let &InstructionData::Unary {

            

        

            

                3264
            

            

                
            

            

                
                                                    opcode: ref v339,

            

        

            

                3265
            

            

                
            

            

                
                                                    arg: v340,

            

        

            

                3266
            

            

                
            

            

                
                                                } = &v253.1

            

        

            

                3267
            

            

                
            

            

                
                                                {

            

        

            

                3268
            

            

                
            

            

                
                                                    if let &Opcode::Uextend = v339 {

            

        

            

                3269
            

            

                
            

            

                
                                                        let v347 = C::inst_data_etor(ctx, v340);

            

        

            

                3270
            

            

                
            

            

                
                                                        let mut v347 = v347;

            

        

            

                3271
            

            

                
            

            

                
                                                        while let Some(v348) = v347.next(ctx) {

            

        

            

                3272
            

            

                
            

            

                
                                                            if let &InstructionData::IntCompare {

            

        

            

                3273
            

            

                
            

            

                
                                                                opcode: ref v351,

            

        

            

                3274
            

            

                
            

            

                
                                                                args: ref v352,

            

        

            

                3275
            

            

                
            

            

                
                                                                cond: ref v353,

            

        

            

                3276
            

            

                
            

            

                
                                                            } = &v348.1

            

        

            

                3277
            

            

                
            

            

                
                                                            {

            

        

            

                3278
            

            

                
            

            

                
                                                                if let &Opcode::Icmp = v351 {

            

        

            

                3279
            

            

                
            

            

                
                                                                    if v2.0 == v348.0 {

            

        

            

                3280
            

            

                
            

            

                
                                                                        let v357 =

            

        

            

                3281
            

            

                
            

            

                
                                                                            C::subsume(ctx, v340);

            

        

            

                3282
            

            

                
            

            

                
                                                                        // Rule at src/opts/icmp.isle line 17.

            

        

            

                3283
            

            

                
            

            

                
                                                                        returns.push(v357);

            

        

            

                3284
            

            

                
            

            

                
                                                                    }

            

        

            

                3285
            

            

                
            

            

                
                                                                }

            

        

            

                3286
            

            

                
            

            

                
                                                            }

            

        

            

                3287
            

            

                
            

            

                
                                                        }

            

        

            

                3288
            

            

                
            

            

                
                                                    }

            

        

            

                3289
            

            

                
            

            

                
                                                }

            

        

            

                3290
            

            

                
            

            

                
                                            }

            

        

            

                3291
            

            

                
            

            

                
                                        }

            

        

            

                3292
            

            

                
            

            

                
                                    }

            

        

            

                3293
            

            

                
            

            

                
                                }

            

        

            

                3294
            

            

                
            

            

                
                            }

            

        

            

                3295
            

            

                
            

            

                
                            let v44 = C::fits_in_64(ctx, v2.0);

            

        

            

                3296
            

            

                
            

            

                
                            if let Some(v45) = v44 {

            

        

            

                3297
            

            

                
            

            

                
                                let v46 = C::ty_int(ctx, v45);

            

        

            

                3298
            

            

                
            

            

                
                                if let Some(v47) = v46 {

            

        

            

                3299
            

            

                
            

            

                
                                    if v172.0 == v172.1 {

            

        

            

                3300
            

            

                
            

            

                
                                        let v49 = C::imm64(ctx, 0x0);

            

        

            

                3301
            

            

                
            

            

                
                                        let v50 = constructor_iconst(ctx, v47, v49);

            

        

            

                3302
            

            

                
            

            

                
                                        // Rule at src/opts/icmp.isle line 6.

            

        

            

                3303
            

            

                
            

            

                
                                        returns.push(v50);

            

        

            

                3304
            

            

                
            

            

                
                                    }

            

        

            

                3305
            

            

                
            

            

                
                                }

            

        

            

                3306
            

            

                
            

            

                
                            }

            

        

            

                3307
            

            

                
            

            

                
                        }

            

        

            

                3308
            

            

                
            

            

                
                        &IntCC::SignedGreaterThan => {

            

        

            

                3309
            

            

                
            

            

                
                            let v44 = C::fits_in_64(ctx, v2.0);

            

        

            

                3310
            

            

                
            

            

                
                            if let Some(v45) = v44 {

            

        

            

                3311
            

            

                
            

            

                
                                let v46 = C::ty_int(ctx, v45);

            

        

            

                3312
            

            

                
            

            

                
                                if let Some(v47) = v46 {

            

        

            

                3313
            

            

                
            

            

                
                                    let v172 = C::unpack_value_array_2(ctx, v170);

            

        

            

                3314
            

            

                
            

            

                
                                    let v175 = C::inst_data_etor(ctx, v172.1);

            

        

            

                3315
            

            

                
            

            

                
                                    let mut v175 = v175;

            

        

            

                3316
            

            

                
            

            

                
                                    while let Some(v176) = v175.next(ctx) {

            

        

            

                3317
            

            

                
            

            

                
                                        if let &InstructionData::UnaryImm {

            

        

            

                3318
            

            

                
            

            

                
                                            opcode: ref v179,

            

        

            

                3319
            

            

                
            

            

                
                                            imm: v180,

            

        

            

                3320
            

            

                
            

            

                
                                        } = &v176.1

            

        

            

                3321
            

            

                
            

            

                
                                        {

            

        

            

                3322
            

            

                
            

            

                
                                            if let &Opcode::Iconst = v179 {

            

        

            

                3323
            

            

                
            

            

                
                                                let v181 = C::u64_from_imm64(ctx, v180);

            

        

            

                3324
            

            

                
            

            

                
                                                let v395 = C::ty_smin(ctx, v176.0);

            

        

            

                3325
            

            

                
            

            

                
                                                let v396 = C::u64_eq(ctx, v181, v395);

            

        

            

                3326
            

            

                
            

            

                
                                                if v396 == true {

            

        

            

                3327
            

            

                
            

            

                
                                                    let v391 =

            

        

            

                3328
            

            

                
            

            

                
                                                        constructor_ne(ctx, v47, v172.0, v172.1);

            

        

            

                3329
            

            

                
            

            

                
                                                    // Rule at src/opts/icmp.isle line 98.

            

        

            

                3330
            

            

                
            

            

                
                                                    returns.push(v391);

            

        

            

                3331
            

            

                
            

            

                
                                                }

            

        

            

                3332
            

            

                
            

            

                
                                                let v397 = C::ty_smax(ctx, v176.0);

            

        

            

                3333
            

            

                
            

            

                
                                                let v398 = C::u64_eq(ctx, v181, v397);

            

        

            

                3334
            

            

                
            

            

                
                                                if v398 == true {

            

        

            

                3335
            

            

                
            

            

                
                                                    let v49 = C::imm64(ctx, 0x0);

            

        

            

                3336
            

            

                
            

            

                
                                                    let v50 = constructor_iconst(ctx, v47, v49);

            

        

            

                3337
            

            

                
            

            

                
                                                    let v51 = C::subsume(ctx, v50);

            

        

            

                3338
            

            

                
            

            

                
                                                    // Rule at src/opts/icmp.isle line 118.

            

        

            

                3339
            

            

                
            

            

                
                                                    returns.push(v51);

            

        

            

                3340
            

            

                
            

            

                
                                                }

            

        

            

                3341
            

            

                
            

            

                
                                            }

            

        

            

                3342
            

            

                
            

            

                
                                        }

            

        

            

                3343
            

            

                
            

            

                
                                    }

            

        

            

                3344
            

            

                
            

            

                
                                    if v172.0 == v172.1 {

            

        

            

                3345
            

            

                
            

            

                
                                        let v49 = C::imm64(ctx, 0x0);

            

        

            

                3346
            

            

                
            

            

                
                                        let v50 = constructor_iconst(ctx, v47, v49);

            

        

            

                3347
            

            

                
            

            

                
                                        // Rule at src/opts/icmp.isle line 9.

            

        

            

                3348
            

            

                
            

            

                
                                        returns.push(v50);

            

        

            

                3349
            

            

                
            

            

                
                                    }

            

        

            

                3350
            

            

                
            

            

                
                                }

            

        

            

                3351
            

            

                
            

            

                
                            }

            

        

            

                3352
            

            

                
            

            

                
                        }

            

        

            

                3353
            

            

                
            

            

                
                        &IntCC::SignedGreaterThanOrEqual => {

            

        

            

                3354
            

            

                
            

            

                
                            let v44 = C::fits_in_64(ctx, v2.0);

            

        

            

                3355
            

            

                
            

            

                
                            if let Some(v45) = v44 {

            

        

            

                3356
            

            

                
            

            

                
                                let v46 = C::ty_int(ctx, v45);

            

        

            

                3357
            

            

                
            

            

                
                                if let Some(v47) = v46 {

            

        

            

                3358
            

            

                
            

            

                
                                    let v172 = C::unpack_value_array_2(ctx, v170);

            

        

            

                3359
            

            

                
            

            

                
                                    let v175 = C::inst_data_etor(ctx, v172.1);

            

        

            

                3360
            

            

                
            

            

                
                                    let mut v175 = v175;

            

        

            

                3361
            

            

                
            

            

                
                                    while let Some(v176) = v175.next(ctx) {

            

        

            

                3362
            

            

                
            

            

                
                                        if let &InstructionData::UnaryImm {

            

        

            

                3363
            

            

                
            

            

                
                                            opcode: ref v179,

            

        

            

                3364
            

            

                
            

            

                
                                            imm: v180,

            

        

            

                3365
            

            

                
            

            

                
                                        } = &v176.1

            

        

            

                3366
            

            

                
            

            

                
                                        {

            

        

            

                3367
            

            

                
            

            

                
                                            if let &Opcode::Iconst = v179 {

            

        

            

                3368
            

            

                
            

            

                
                                                let v181 = C::u64_from_imm64(ctx, v180);

            

        

            

                3369
            

            

                
            

            

                
                                                let v395 = C::ty_smin(ctx, v176.0);

            

        

            

                3370
            

            

                
            

            

                
                                                let v396 = C::u64_eq(ctx, v181, v395);

            

        

            

                3371
            

            

                
            

            

                
                                                if v396 == true {

            

        

            

                3372
            

            

                
            

            

                
                                                    let v343 = C::imm64(ctx, 0x1);

            

        

            

                3373
            

            

                
            

            

                
                                                    let v346 = constructor_iconst(ctx, v47, v343);

            

        

            

                3374
            

            

                
            

            

                
                                                    let v392 = C::subsume(ctx, v346);

            

        

            

                3375
            

            

                
            

            

                
                                                    // Rule at src/opts/icmp.isle line 103.

            

        

            

                3376
            

            

                
            

            

                
                                                    returns.push(v392);

            

        

            

                3377
            

            

                
            

            

                
                                                }

            

        

            

                3378
            

            

                
            

            

                
                                                let v397 = C::ty_smax(ctx, v176.0);

            

        

            

                3379
            

            

                
            

            

                
                                                let v398 = C::u64_eq(ctx, v181, v397);

            

        

            

                3380
            

            

                
            

            

                
                                                if v398 == true {

            

        

            

                3381
            

            

                
            

            

                
                                                    let v390 =

            

        

            

                3382
            

            

                
            

            

                
                                                        constructor_eq(ctx, v47, v172.0, v172.1);

            

        

            

                3383
            

            

                
            

            

                
                                                    // Rule at src/opts/icmp.isle line 123.

            

        

            

                3384
            

            

                
            

            

                
                                                    returns.push(v390);

            

        

            

                3385
            

            

                
            

            

                
                                                }

            

        

            

                3386
            

            

                
            

            

                
                                            }

            

        

            

                3387
            

            

                
            

            

                
                                        }

            

        

            

                3388
            

            

                
            

            

                
                                    }

            

        

            

                3389
            

            

                
            

            

                
                                    if v172.0 == v172.1 {

            

        

            

                3390
            

            

                
            

            

                
                                        let v343 = C::imm64(ctx, 0x1);

            

        

            

                3391
            

            

                
            

            

                
                                        let v346 = constructor_iconst(ctx, v47, v343);

            

        

            

                3392
            

            

                
            

            

                
                                        // Rule at src/opts/icmp.isle line 10.

            

        

            

                3393
            

            

                
            

            

                
                                        returns.push(v346);

            

        

            

                3394
            

            

                
            

            

                
                                    }

            

        

            

                3395
            

            

                
            

            

                
                                }

            

        

            

                3396
            

            

                
            

            

                
                            }

            

        

            

                3397
            

            

                
            

            

                
                            let v172 = C::unpack_value_array_2(ctx, v170);

            

        

            

                3398
            

            

                
            

            

                
                            let v175 = C::inst_data_etor(ctx, v172.1);

            

        

            

                3399
            

            

                
            

            

                
                            let mut v175 = v175;

            

        

            

                3400
            

            

                
            

            

                
                            while let Some(v176) = v175.next(ctx) {

            

        

            

                3401
            

            

                
            

            

                
                                if let &InstructionData::UnaryImm {

            

        

            

                3402
            

            

                
            

            

                
                                    opcode: ref v179,

            

        

            

                3403
            

            

                
            

            

                
                                    imm: v180,

            

        

            

                3404
            

            

                
            

            

                
                                } = &v176.1

            

        

            

                3405
            

            

                
            

            

                
                                {

            

        

            

                3406
            

            

                
            

            

                
                                    if let &Opcode::Iconst = v179 {

            

        

            

                3407
            

            

                
            

            

                
                                        let v181 = C::u64_from_imm64(ctx, v180);

            

        

            

                3408
            

            

                
            

            

                
                                        if v181 == 0x0 {

            

        

            

                3409
            

            

                
            

            

                
                                            let v252 = C::inst_data_etor(ctx, v172.0);

            

        

            

                3410
            

            

                
            

            

                
                                            let mut v252 = v252;

            

        

            

                3411
            

            

                
            

            

                
                                            while let Some(v253) = v252.next(ctx) {

            

        

            

                3412
            

            

                
            

            

                
                                                if v253.0 == I64 {

            

        

            

                3413
            

            

                
            

            

                
                                                    if let &InstructionData::Unary {

            

        

            

                3414
            

            

                
            

            

                
                                                        opcode: ref v339,

            

        

            

                3415
            

            

                
            

            

                
                                                        arg: v340,

            

        

            

                3416
            

            

                
            

            

                
                                                    } = &v253.1

            

        

            

                3417
            

            

                
            

            

                
                                                    {

            

        

            

                3418
            

            

                
            

            

                
                                                        if let &Opcode::Uextend = v339 {

            

        

            

                3419
            

            

                
            

            

                
                                                            let v341 = C::value_type(ctx, v340);

            

        

            

                3420
            

            

                
            

            

                
                                                            if v341 == I32 {

            

        

            

                3421
            

            

                
            

            

                
                                                                let v343 = C::imm64(ctx, 0x1);

            

        

            

                3422
            

            

                
            

            

                
                                                                let v344 = constructor_iconst(

            

        

            

                3423
            

            

                
            

            

                
                                                                    ctx, v2.0, v343,

            

        

            

                3424
            

            

                
            

            

                
                                                                );

            

        

            

                3425
            

            

                
            

            

                
                                                                // Rule at src/opts/extends.isle line 25.

            

        

            

                3426
            

            

                
            

            

                
                                                                returns.push(v344);

            

        

            

                3427
            

            

                
            

            

                
                                                            }

            

        

            

                3428
            

            

                
            

            

                
                                                        }

            

        

            

                3429
            

            

                
            

            

                
                                                    }

            

        

            

                3430
            

            

                
            

            

                
                                                }

            

        

            

                3431
            

            

                
            

            

                
                                            }

            

        

            

                3432
            

            

                
            

            

                
                                        }

            

        

            

                3433
            

            

                
            

            

                
                                    }

            

        

            

                3434
            

            

                
            

            

                
                                }

            

        

            

                3435
            

            

                
            

            

                
                            }

            

        

            

                3436
            

            

                
            

            

                
                        }

            

        

            

                3437
            

            

                
            

            

                
                        &IntCC::SignedLessThan => {

            

        

            

                3438
            

            

                
            

            

                
                            let v44 = C::fits_in_64(ctx, v2.0);

            

        

            

                3439
            

            

                
            

            

                
                            if let Some(v45) = v44 {

            

        

            

                3440
            

            

                
            

            

                
                                let v46 = C::ty_int(ctx, v45);

            

        

            

                3441
            

            

                
            

            

                
                                if let Some(v47) = v46 {

            

        

            

                3442
            

            

                
            

            

                
                                    let v172 = C::unpack_value_array_2(ctx, v170);

            

        

            

                3443
            

            

                
            

            

                
                                    let v175 = C::inst_data_etor(ctx, v172.1);

            

        

            

                3444
            

            

                
            

            

                
                                    let mut v175 = v175;

            

        

            

                3445
            

            

                
            

            

                
                                    while let Some(v176) = v175.next(ctx) {

            

        

            

                3446
            

            

                
            

            

                
                                        if let &InstructionData::UnaryImm {

            

        

            

                3447
            

            

                
            

            

                
                                            opcode: ref v179,

            

        

            

                3448
            

            

                
            

            

                
                                            imm: v180,

            

        

            

                3449
            

            

                
            

            

                
                                        } = &v176.1

            

        

            

                3450
            

            

                
            

            

                
                                        {

            

        

            

                3451
            

            

                
            

            

                
                                            if let &Opcode::Iconst = v179 {

            

        

            

                3452
            

            

                
            

            

                
                                                let v181 = C::u64_from_imm64(ctx, v180);

            

        

            

                3453
            

            

                
            

            

                
                                                let v395 = C::ty_smin(ctx, v176.0);

            

        

            

                3454
            

            

                
            

            

                
                                                let v396 = C::u64_eq(ctx, v181, v395);

            

        

            

                3455
            

            

                
            

            

                
                                                if v396 == true {

            

        

            

                3456
            

            

                
            

            

                
                                                    let v49 = C::imm64(ctx, 0x0);

            

        

            

                3457
            

            

                
            

            

                
                                                    let v50 = constructor_iconst(ctx, v47, v49);

            

        

            

                3458
            

            

                
            

            

                
                                                    let v51 = C::subsume(ctx, v50);

            

        

            

                3459
            

            

                
            

            

                
                                                    // Rule at src/opts/icmp.isle line 88.

            

        

            

                3460
            

            

                
            

            

                
                                                    returns.push(v51);

            

        

            

                3461
            

            

                
            

            

                
                                                }

            

        

            

                3462
            

            

                
            

            

                
                                                let v397 = C::ty_smax(ctx, v176.0);

            

        

            

                3463
            

            

                
            

            

                
                                                let v398 = C::u64_eq(ctx, v181, v397);

            

        

            

                3464
            

            

                
            

            

                
                                                if v398 == true {

            

        

            

                3465
            

            

                
            

            

                
                                                    let v391 =

            

        

            

                3466
            

            

                
            

            

                
                                                        constructor_ne(ctx, v47, v172.0, v172.1);

            

        

            

                3467
            

            

                
            

            

                
                                                    // Rule at src/opts/icmp.isle line 108.

            

        

            

                3468
            

            

                
            

            

                
                                                    returns.push(v391);

            

        

            

                3469
            

            

                
            

            

                
                                                }

            

        

            

                3470
            

            

                
            

            

                
                                            }

            

        

            

                3471
            

            

                
            

            

                
                                        }

            

        

            

                3472
            

            

                
            

            

                
                                    }

            

        

            

                3473
            

            

                
            

            

                
                                    if v172.0 == v172.1 {

            

        

            

                3474
            

            

                
            

            

                
                                        let v49 = C::imm64(ctx, 0x0);

            

        

            

                3475
            

            

                
            

            

                
                                        let v50 = constructor_iconst(ctx, v47, v49);

            

        

            

                3476
            

            

                
            

            

                
                                        // Rule at src/opts/icmp.isle line 13.

            

        

            

                3477
            

            

                
            

            

                
                                        returns.push(v50);

            

        

            

                3478
            

            

                
            

            

                
                                    }

            

        

            

                3479
            

            

                
            

            

                
                                }

            

        

            

                3480
            

            

                
            

            

                
                            }

            

        

            

                3481
            

            

                
            

            

                
                            let v172 = C::unpack_value_array_2(ctx, v170);

            

        

            

                3482
            

            

                
            

            

                
                            let v175 = C::inst_data_etor(ctx, v172.1);

            

        

            

                3483
            

            

                
            

            

                
                            let mut v175 = v175;

            

        

            

                3484
            

            

                
            

            

                
                            while let Some(v176) = v175.next(ctx) {

            

        

            

                3485
            

            

                
            

            

                
                                if let &InstructionData::UnaryImm {

            

        

            

                3486
            

            

                
            

            

                
                                    opcode: ref v179,

            

        

            

                3487
            

            

                
            

            

                
                                    imm: v180,

            

        

            

                3488
            

            

                
            

            

                
                                } = &v176.1

            

        

            

                3489
            

            

                
            

            

                
                                {

            

        

            

                3490
            

            

                
            

            

                
                                    if let &Opcode::Iconst = v179 {

            

        

            

                3491
            

            

                
            

            

                
                                        let v181 = C::u64_from_imm64(ctx, v180);

            

        

            

                3492
            

            

                
            

            

                
                                        if v181 == 0x0 {

            

        

            

                3493
            

            

                
            

            

                
                                            let v252 = C::inst_data_etor(ctx, v172.0);

            

        

            

                3494
            

            

                
            

            

                
                                            let mut v252 = v252;

            

        

            

                3495
            

            

                
            

            

                
                                            while let Some(v253) = v252.next(ctx) {

            

        

            

                3496
            

            

                
            

            

                
                                                if v253.0 == I64 {

            

        

            

                3497
            

            

                
            

            

                
                                                    if let &InstructionData::Unary {

            

        

            

                3498
            

            

                
            

            

                
                                                        opcode: ref v339,

            

        

            

                3499
            

            

                
            

            

                
                                                        arg: v340,

            

        

            

                3500
            

            

                
            

            

                
                                                    } = &v253.1

            

        

            

                3501
            

            

                
            

            

                
                                                    {

            

        

            

                3502
            

            

                
            

            

                
                                                        if let &Opcode::Uextend = v339 {

            

        

            

                3503
            

            

                
            

            

                
                                                            let v341 = C::value_type(ctx, v340);

            

        

            

                3504
            

            

                
            

            

                
                                                            if v341 == I32 {

            

        

            

                3505
            

            

                
            

            

                
                                                                let v49 = C::imm64(ctx, 0x0);

            

        

            

                3506
            

            

                
            

            

                
                                                                let v342 = constructor_iconst(

            

        

            

                3507
            

            

                
            

            

                
                                                                    ctx, v2.0, v49,

            

        

            

                3508
            

            

                
            

            

                
                                                                );

            

        

            

                3509
            

            

                
            

            

                
                                                                // Rule at src/opts/extends.isle line 20.

            

        

            

                3510
            

            

                
            

            

                
                                                                returns.push(v342);

            

        

            

                3511
            

            

                
            

            

                
                                                            }

            

        

            

                3512
            

            

                
            

            

                
                                                        }

            

        

            

                3513
            

            

                
            

            

                
                                                    }

            

        

            

                3514
            

            

                
            

            

                
                                                }

            

        

            

                3515
            

            

                
            

            

                
                                            }

            

        

            

                3516
            

            

                
            

            

                
                                        }

            

        

            

                3517
            

            

                
            

            

                
                                    }

            

        

            

                3518
            

            

                
            

            

                
                                }

            

        

            

                3519
            

            

                
            

            

                
                            }

            

        

            

                3520
            

            

                
            

            

                
                        }

            

        

            

                3521
            

            

                
            

            

                
                        &IntCC::SignedLessThanOrEqual => {

            

        

            

                3522
            

            

                
            

            

                
                            let v44 = C::fits_in_64(ctx, v2.0);

            

        

            

                3523
            

            

                
            

            

                
                            if let Some(v45) = v44 {

            

        

            

                3524
            

            

                
            

            

                
                                let v46 = C::ty_int(ctx, v45);

            

        

            

                3525
            

            

                
            

            

                
                                if let Some(v47) = v46 {

            

        

            

                3526
            

            

                
            

            

                
                                    let v172 = C::unpack_value_array_2(ctx, v170);

            

        

            

                3527
            

            

                
            

            

                
                                    let v175 = C::inst_data_etor(ctx, v172.1);

            

        

            

                3528
            

            

                
            

            

                
                                    let mut v175 = v175;

            

        

            

                3529
            

            

                
            

            

                
                                    while let Some(v176) = v175.next(ctx) {

            

        

            

                3530
            

            

                
            

            

                
                                        if let &InstructionData::UnaryImm {

            

        

            

                3531
            

            

                
            

            

                
                                            opcode: ref v179,

            

        

            

                3532
            

            

                
            

            

                
                                            imm: v180,

            

        

            

                3533
            

            

                
            

            

                
                                        } = &v176.1

            

        

            

                3534
            

            

                
            

            

                
                                        {

            

        

            

                3535
            

            

                
            

            

                
                                            if let &Opcode::Iconst = v179 {

            

        

            

                3536
            

            

                
            

            

                
                                                let v181 = C::u64_from_imm64(ctx, v180);

            

        

            

                3537
            

            

                
            

            

                
                                                let v395 = C::ty_smin(ctx, v176.0);

            

        

            

                3538
            

            

                
            

            

                
                                                let v396 = C::u64_eq(ctx, v181, v395);

            

        

            

                3539
            

            

                
            

            

                
                                                if v396 == true {

            

        

            

                3540
            

            

                
            

            

                
                                                    let v390 =

            

        

            

                3541
            

            

                
            

            

                
                                                        constructor_eq(ctx, v47, v172.0, v172.1);

            

        

            

                3542
            

            

                
            

            

                
                                                    // Rule at src/opts/icmp.isle line 93.

            

        

            

                3543
            

            

                
            

            

                
                                                    returns.push(v390);

            

        

            

                3544
            

            

                
            

            

                
                                                }

            

        

            

                3545
            

            

                
            

            

                
                                                let v397 = C::ty_smax(ctx, v176.0);

            

        

            

                3546
            

            

                
            

            

                
                                                let v398 = C::u64_eq(ctx, v181, v397);

            

        

            

                3547
            

            

                
            

            

                
                                                if v398 == true {

            

        

            

                3548
            

            

                
            

            

                
                                                    let v343 = C::imm64(ctx, 0x1);

            

        

            

                3549
            

            

                
            

            

                
                                                    let v346 = constructor_iconst(ctx, v47, v343);

            

        

            

                3550
            

            

                
            

            

                
                                                    let v392 = C::subsume(ctx, v346);

            

        

            

                3551
            

            

                
            

            

                
                                                    // Rule at src/opts/icmp.isle line 113.

            

        

            

                3552
            

            

                
            

            

                
                                                    returns.push(v392);

            

        

            

                3553
            

            

                
            

            

                
                                                }

            

        

            

                3554
            

            

                
            

            

                
                                            }

            

        

            

                3555
            

            

                
            

            

                
                                        }

            

        

            

                3556
            

            

                
            

            

                
                                    }

            

        

            

                3557
            

            

                
            

            

                
                                    if v172.0 == v172.1 {

            

        

            

                3558
            

            

                
            

            

                
                                        let v343 = C::imm64(ctx, 0x1);

            

        

            

                3559
            

            

                
            

            

                
                                        let v346 = constructor_iconst(ctx, v47, v343);

            

        

            

                3560
            

            

                
            

            

                
                                        // Rule at src/opts/icmp.isle line 14.

            

        

            

                3561
            

            

                
            

            

                
                                        returns.push(v346);

            

        

            

                3562
            

            

                
            

            

                
                                    }

            

        

            

                3563
            

            

                
            

            

                
                                }

            

        

            

                3564
            

            

                
            

            

                
                            }

            

        

            

                3565
            

            

                
            

            

                
                        }

            

        

            

                3566
            

            

                
            

            

                
                        &IntCC::UnsignedGreaterThan => {

            

        

            

                3567
            

            

                
            

            

                
                            let v44 = C::fits_in_64(ctx, v2.0);

            

        

            

                3568
            

            

                
            

            

                
                            if let Some(v45) = v44 {

            

        

            

                3569
            

            

                
            

            

                
                                let v46 = C::ty_int(ctx, v45);

            

        

            

                3570
            

            

                
            

            

                
                                if let Some(v47) = v46 {

            

        

            

                3571
            

            

                
            

            

                
                                    let v172 = C::unpack_value_array_2(ctx, v170);

            

        

            

                3572
            

            

                
            

            

                
                                    let v175 = C::inst_data_etor(ctx, v172.1);

            

        

            

                3573
            

            

                
            

            

                
                                    let mut v175 = v175;

            

        

            

                3574
            

            

                
            

            

                
                                    while let Some(v176) = v175.next(ctx) {

            

        

            

                3575
            

            

                
            

            

                
                                        if let &InstructionData::UnaryImm {

            

        

            

                3576
            

            

                
            

            

                
                                            opcode: ref v179,

            

        

            

                3577
            

            

                
            

            

                
                                            imm: v180,

            

        

            

                3578
            

            

                
            

            

                
                                        } = &v176.1

            

        

            

                3579
            

            

                
            

            

                
                                        {

            

        

            

                3580
            

            

                
            

            

                
                                            if let &Opcode::Iconst = v179 {

            

        

            

                3581
            

            

                
            

            

                
                                                let v181 = C::u64_from_imm64(ctx, v180);

            

        

            

                3582
            

            

                
            

            

                
                                                if v181 == 0x0 {

            

        

            

                3583
            

            

                
            

            

                
                                                    let v391 =

            

        

            

                3584
            

            

                
            

            

                
                                                        constructor_ne(ctx, v47, v172.0, v172.1);

            

        

            

                3585
            

            

                
            

            

                
                                                    // Rule at src/opts/icmp.isle line 60.

            

        

            

                3586
            

            

                
            

            

                
                                                    returns.push(v391);

            

        

            

                3587
            

            

                
            

            

                
                                                }

            

        

            

                3588
            

            

                
            

            

                
                                                let v393 = C::ty_umax(ctx, v176.0);

            

        

            

                3589
            

            

                
            

            

                
                                                let v394 = C::u64_eq(ctx, v181, v393);

            

        

            

                3590
            

            

                
            

            

                
                                                if v394 == true {

            

        

            

                3591
            

            

                
            

            

                
                                                    let v49 = C::imm64(ctx, 0x0);

            

        

            

                3592
            

            

                
            

            

                
                                                    let v50 = constructor_iconst(ctx, v47, v49);

            

        

            

                3593
            

            

                
            

            

                
                                                    let v51 = C::subsume(ctx, v50);

            

        

            

                3594
            

            

                
            

            

                
                                                    // Rule at src/opts/icmp.isle line 78.

            

        

            

                3595
            

            

                
            

            

                
                                                    returns.push(v51);

            

        

            

                3596
            

            

                
            

            

                
                                                }

            

        

            

                3597
            

            

                
            

            

                
                                            }

            

        

            

                3598
            

            

                
            

            

                
                                        }

            

        

            

                3599
            

            

                
            

            

                
                                    }

            

        

            

                3600
            

            

                
            

            

                
                                    if v172.0 == v172.1 {

            

        

            

                3601
            

            

                
            

            

                
                                        let v49 = C::imm64(ctx, 0x0);

            

        

            

                3602
            

            

                
            

            

                
                                        let v50 = constructor_iconst(ctx, v47, v49);

            

        

            

                3603
            

            

                
            

            

                
                                        // Rule at src/opts/icmp.isle line 7.

            

        

            

                3604
            

            

                
            

            

                
                                        returns.push(v50);

            

        

            

                3605
            

            

                
            

            

                
                                    }

            

        

            

                3606
            

            

                
            

            

                
                                }

            

        

            

                3607
            

            

                
            

            

                
                            }

            

        

            

                3608
            

            

                
            

            

                
                        }

            

        

            

                3609
            

            

                
            

            

                
                        &IntCC::UnsignedGreaterThanOrEqual => {

            

        

            

                3610
            

            

                
            

            

                
                            let v44 = C::fits_in_64(ctx, v2.0);

            

        

            

                3611
            

            

                
            

            

                
                            if let Some(v45) = v44 {

            

        

            

                3612
            

            

                
            

            

                
                                let v46 = C::ty_int(ctx, v45);

            

        

            

                3613
            

            

                
            

            

                
                                if let Some(v47) = v46 {

            

        

            

                3614
            

            

                
            

            

                
                                    let v172 = C::unpack_value_array_2(ctx, v170);

            

        

            

                3615
            

            

                
            

            

                
                                    let v175 = C::inst_data_etor(ctx, v172.1);

            

        

            

                3616
            

            

                
            

            

                
                                    let mut v175 = v175;

            

        

            

                3617
            

            

                
            

            

                
                                    while let Some(v176) = v175.next(ctx) {

            

        

            

                3618
            

            

                
            

            

                
                                        if let &InstructionData::UnaryImm {

            

        

            

                3619
            

            

                
            

            

                
                                            opcode: ref v179,

            

        

            

                3620
            

            

                
            

            

                
                                            imm: v180,

            

        

            

                3621
            

            

                
            

            

                
                                        } = &v176.1

            

        

            

                3622
            

            

                
            

            

                
                                        {

            

        

            

                3623
            

            

                
            

            

                
                                            if let &Opcode::Iconst = v179 {

            

        

            

                3624
            

            

                
            

            

                
                                                let v181 = C::u64_from_imm64(ctx, v180);

            

        

            

                3625
            

            

                
            

            

                
                                                if v181 == 0x0 {

            

        

            

                3626
            

            

                
            

            

                
                                                    let v343 = C::imm64(ctx, 0x1);

            

        

            

                3627
            

            

                
            

            

                
                                                    let v346 = constructor_iconst(ctx, v47, v343);

            

        

            

                3628
            

            

                
            

            

                
                                                    let v392 = C::subsume(ctx, v346);

            

        

            

                3629
            

            

                
            

            

                
                                                    // Rule at src/opts/icmp.isle line 64.

            

        

            

                3630
            

            

                
            

            

                
                                                    returns.push(v392);

            

        

            

                3631
            

            

                
            

            

                
                                                }

            

        

            

                3632
            

            

                
            

            

                
                                                let v393 = C::ty_umax(ctx, v176.0);

            

        

            

                3633
            

            

                
            

            

                
                                                let v394 = C::u64_eq(ctx, v181, v393);

            

        

            

                3634
            

            

                
            

            

                
                                                if v394 == true {

            

        

            

                3635
            

            

                
            

            

                
                                                    let v390 =

            

        

            

                3636
            

            

                
            

            

                
                                                        constructor_eq(ctx, v47, v172.0, v172.1);

            

        

            

                3637
            

            

                
            

            

                
                                                    // Rule at src/opts/icmp.isle line 83.

            

        

            

                3638
            

            

                
            

            

                
                                                    returns.push(v390);

            

        

            

                3639
            

            

                
            

            

                
                                                }

            

        

            

                3640
            

            

                
            

            

                
                                            }

            

        

            

                3641
            

            

                
            

            

                
                                        }

            

        

            

                3642
            

            

                
            

            

                
                                    }

            

        

            

                3643
            

            

                
            

            

                
                                    if v172.0 == v172.1 {

            

        

            

                3644
            

            

                
            

            

                
                                        let v343 = C::imm64(ctx, 0x1);

            

        

            

                3645
            

            

                
            

            

                
                                        let v346 = constructor_iconst(ctx, v47, v343);

            

        

            

                3646
            

            

                
            

            

                
                                        // Rule at src/opts/icmp.isle line 8.

            

        

            

                3647
            

            

                
            

            

                
                                        returns.push(v346);

            

        

            

                3648
            

            

                
            

            

                
                                    }

            

        

            

                3649
            

            

                
            

            

                
                                }

            

        

            

                3650
            

            

                
            

            

                
                            }

            

        

            

                3651
            

            

                
            

            

                
                        }

            

        

            

                3652
            

            

                
            

            

                
                        &IntCC::UnsignedLessThan => {

            

        

            

                3653
            

            

                
            

            

                
                            let v44 = C::fits_in_64(ctx, v2.0);

            

        

            

                3654
            

            

                
            

            

                
                            if let Some(v45) = v44 {

            

        

            

                3655
            

            

                
            

            

                
                                let v46 = C::ty_int(ctx, v45);

            

        

            

                3656
            

            

                
            

            

                
                                if let Some(v47) = v46 {

            

        

            

                3657
            

            

                
            

            

                
                                    let v172 = C::unpack_value_array_2(ctx, v170);

            

        

            

                3658
            

            

                
            

            

                
                                    let v175 = C::inst_data_etor(ctx, v172.1);

            

        

            

                3659
            

            

                
            

            

                
                                    let mut v175 = v175;

            

        

            

                3660
            

            

                
            

            

                
                                    while let Some(v176) = v175.next(ctx) {

            

        

            

                3661
            

            

                
            

            

                
                                        if let &InstructionData::UnaryImm {

            

        

            

                3662
            

            

                
            

            

                
                                            opcode: ref v179,

            

        

            

                3663
            

            

                
            

            

                
                                            imm: v180,

            

        

            

                3664
            

            

                
            

            

                
                                        } = &v176.1

            

        

            

                3665
            

            

                
            

            

                
                                        {

            

        

            

                3666
            

            

                
            

            

                
                                            if let &Opcode::Iconst = v179 {

            

        

            

                3667
            

            

                
            

            

                
                                                let v181 = C::u64_from_imm64(ctx, v180);

            

        

            

                3668
            

            

                
            

            

                
                                                if v181 == 0x0 {

            

        

            

                3669
            

            

                
            

            

                
                                                    let v49 = C::imm64(ctx, 0x0);

            

        

            

                3670
            

            

                
            

            

                
                                                    let v50 = constructor_iconst(ctx, v47, v49);

            

        

            

                3671
            

            

                
            

            

                
                                                    let v51 = C::subsume(ctx, v50);

            

        

            

                3672
            

            

                
            

            

                
                                                    // Rule at src/opts/icmp.isle line 52.

            

        

            

                3673
            

            

                
            

            

                
                                                    returns.push(v51);

            

        

            

                3674
            

            

                
            

            

                
                                                }

            

        

            

                3675
            

            

                
            

            

                
                                                let v393 = C::ty_umax(ctx, v176.0);

            

        

            

                3676
            

            

                
            

            

                
                                                let v394 = C::u64_eq(ctx, v181, v393);

            

        

            

                3677
            

            

                
            

            

                
                                                if v394 == true {

            

        

            

                3678
            

            

                
            

            

                
                                                    let v391 =

            

        

            

                3679
            

            

                
            

            

                
                                                        constructor_ne(ctx, v47, v172.0, v172.1);

            

        

            

                3680
            

            

                
            

            

                
                                                    // Rule at src/opts/icmp.isle line 68.

            

        

            

                3681
            

            

                
            

            

                
                                                    returns.push(v391);

            

        

            

                3682
            

            

                
            

            

                
                                                }

            

        

            

                3683
            

            

                
            

            

                
                                            }

            

        

            

                3684
            

            

                
            

            

                
                                        }

            

        

            

                3685
            

            

                
            

            

                
                                    }

            

        

            

                3686
            

            

                
            

            

                
                                    if v172.0 == v172.1 {

            

        

            

                3687
            

            

                
            

            

                
                                        let v49 = C::imm64(ctx, 0x0);

            

        

            

                3688
            

            

                
            

            

                
                                        let v50 = constructor_iconst(ctx, v47, v49);

            

        

            

                3689
            

            

                
            

            

                
                                        // Rule at src/opts/icmp.isle line 11.

            

        

            

                3690
            

            

                
            

            

                
                                        returns.push(v50);

            

        

            

                3691
            

            

                
            

            

                
                                    }

            

        

            

                3692
            

            

                
            

            

                
                                }

            

        

            

                3693
            

            

                
            

            

                
                            }

            

        

            

                3694
            

            

                
            

            

                
                        }

            

        

            

                3695
            

            

                
            

            

                
                        &IntCC::UnsignedLessThanOrEqual => {

            

        

            

                3696
            

            

                
            

            

                
                            let v44 = C::fits_in_64(ctx, v2.0);

            

        

            

                3697
            

            

                
            

            

                
                            if let Some(v45) = v44 {

            

        

            

                3698
            

            

                
            

            

                
                                let v46 = C::ty_int(ctx, v45);

            

        

            

                3699
            

            

                
            

            

                
                                if let Some(v47) = v46 {

            

        

            

                3700
            

            

                
            

            

                
                                    let v172 = C::unpack_value_array_2(ctx, v170);

            

        

            

                3701
            

            

                
            

            

                
                                    let v175 = C::inst_data_etor(ctx, v172.1);

            

        

            

                3702
            

            

                
            

            

                
                                    let mut v175 = v175;

            

        

            

                3703
            

            

                
            

            

                
                                    while let Some(v176) = v175.next(ctx) {

            

        

            

                3704
            

            

                
            

            

                
                                        if let &InstructionData::UnaryImm {

            

        

            

                3705
            

            

                
            

            

                
                                            opcode: ref v179,

            

        

            

                3706
            

            

                
            

            

                
                                            imm: v180,

            

        

            

                3707
            

            

                
            

            

                
                                        } = &v176.1

            

        

            

                3708
            

            

                
            

            

                
                                        {

            

        

            

                3709
            

            

                
            

            

                
                                            if let &Opcode::Iconst = v179 {

            

        

            

                3710
            

            

                
            

            

                
                                                let v181 = C::u64_from_imm64(ctx, v180);

            

        

            

                3711
            

            

                
            

            

                
                                                if v181 == 0x0 {

            

        

            

                3712
            

            

                
            

            

                
                                                    let v390 =

            

        

            

                3713
            

            

                
            

            

                
                                                        constructor_eq(ctx, v47, v172.0, v172.1);

            

        

            

                3714
            

            

                
            

            

                
                                                    // Rule at src/opts/icmp.isle line 56.

            

        

            

                3715
            

            

                
            

            

                
                                                    returns.push(v390);

            

        

            

                3716
            

            

                
            

            

                
                                                }

            

        

            

                3717
            

            

                
            

            

                
                                                let v393 = C::ty_umax(ctx, v176.0);

            

        

            

                3718
            

            

                
            

            

                
                                                let v394 = C::u64_eq(ctx, v181, v393);

            

        

            

                3719
            

            

                
            

            

                
                                                if v394 == true {

            

        

            

                3720
            

            

                
            

            

                
                                                    let v343 = C::imm64(ctx, 0x1);

            

        

            

                3721
            

            

                
            

            

                
                                                    let v346 = constructor_iconst(ctx, v47, v343);

            

        

            

                3722
            

            

                
            

            

                
                                                    let v392 = C::subsume(ctx, v346);

            

        

            

                3723
            

            

                
            

            

                
                                                    // Rule at src/opts/icmp.isle line 73.

            

        

            

                3724
            

            

                
            

            

                
                                                    returns.push(v392);

            

        

            

                3725
            

            

                
            

            

                
                                                }

            

        

            

                3726
            

            

                
            

            

                
                                            }

            

        

            

                3727
            

            

                
            

            

                
                                        }

            

        

            

                3728
            

            

                
            

            

                
                                    }

            

        

            

                3729
            

            

                
            

            

                
                                    if v172.0 == v172.1 {

            

        

            

                3730
            

            

                
            

            

                
                                        let v343 = C::imm64(ctx, 0x1);

            

        

            

                3731
            

            

                
            

            

                
                                        let v346 = constructor_iconst(ctx, v47, v343);

            

        

            

                3732
            

            

                
            

            

                
                                        // Rule at src/opts/icmp.isle line 12.

            

        

            

                3733
            

            

                
            

            

                
                                        returns.push(v346);

            

        

            

                3734
            

            

                
            

            

                
                                    }

            

        

            

                3735
            

            

                
            

            

                
                                }

            

        

            

                3736
            

            

                
            

            

                
                            }

            

        

            

                3737
            

            

                
            

            

                
                        }

            

        

            

                3738
            

            

                
            

            

                
                        _ => {}

            

        

            

                3739
            

            

                
            

            

                
                    }

            

        

            

                3740
            

            

                
            

            

                
                    let v172 = C::unpack_value_array_2(ctx, v170);

            

        

            

                3741
            

            

                
            

            

                
                    let v252 = C::inst_data_etor(ctx, v172.0);

            

        

            

                3742
            

            

                
            

            

                
                    let mut v252 = v252;

            

        

            

                3743
            

            

                
            

            

                
                    while let Some(v253) = v252.next(ctx) {

            

        

            

                3744
            

            

                
            

            

                
                        if let &InstructionData::UnaryImm {

            

        

            

                3745
            

            

                
            

            

                
                            opcode: ref v256,

            

        

            

                3746
            

            

                
            

            

                
                            imm: v257,

            

        

            

                3747
            

            

                
            

            

                
                        } = &v253.1

            

        

            

                3748
            

            

                
            

            

                
                        {

            

        

            

                3749
            

            

                
            

            

                
                            if let &Opcode::Iconst = v256 {

            

        

            

                3750
            

            

                
            

            

                
                                let v175 = C::inst_data_etor(ctx, v172.1);

            

        

            

                3751
            

            

                
            

            

                
                                let mut v175 = v175;

            

        

            

                3752
            

            

                
            

            

                
                                while let Some(v176) = v175.next(ctx) {

            

        

            

                3753
            

            

                
            

            

                
                                    if let &InstructionData::UnaryImm {

            

        

            

                3754
            

            

                
            

            

                
                                        opcode: ref v179,

            

        

            

                3755
            

            

                
            

            

                
                                        imm: v180,

            

        

            

                3756
            

            

                
            

            

                
                                    } = &v176.1

            

        

            

                3757
            

            

                
            

            

                
                                    {

            

        

            

                3758
            

            

                
            

            

                
                                        if let &Opcode::Iconst = v179 {

            

        

            

                3759
            

            

                
            

            

                
                                            if v176.0 == v253.0 {

            

        

            

                3760
            

            

                
            

            

                
                                                let v258 =

            

        

            

                3761
            

            

                
            

            

                
                                                    C::imm64_icmp(ctx, v253.0, v171, v257, v180);

            

        

            

                3762
            

            

                
            

            

                
                                                let v259 = constructor_iconst(ctx, v2.0, v258);

            

        

            

                3763
            

            

                
            

            

                
                                                let v260 = C::subsume(ctx, v259);

            

        

            

                3764
            

            

                
            

            

                
                                                // Rule at src/opts/cprop.isle line 82.

            

        

            

                3765
            

            

                
            

            

                
                                                returns.push(v260);

            

        

            

                3766
            

            

                
            

            

                
                                            }

            

        

            

                3767
            

            

                
            

            

                
                                        }

            

        

            

                3768
            

            

                
            

            

                
                                    }

            

        

            

                3769
            

            

                
            

            

                
                                }

            

        

            

                3770
            

            

                
            

            

                
                                let v268 = &C::intcc_swap_args(ctx, v171);

            

        

            

                3771
            

            

                
            

            

                
                                let v269 = constructor_icmp(ctx, v2.0, v268, v172.1, v172.0);

            

        

            

                3772
            

            

                
            

            

                
                                // Rule at src/opts/cprop.isle line 116.

            

        

            

                3773
            

            

                
            

            

                
                                returns.push(v269);

            

        

            

                3774
            

            

                
            

            

                
                            }

            

        

            

                3775
            

            

                
            

            

                
                        }

            

        

            

                3776
            

            

                
            

            

                
                    }

            

        

            

                3777
            

            

                
            

            

                
                }

            

        

            

                3778
            

            

                
            

            

                
            }

            

        

            

                3779
            

            

                
            

            

                
            &InstructionData::Ternary {

            

        

            

                3780
            

            

                
            

            

                
                opcode: ref v95,

            

        

            

                3781
            

            

                
            

            

                
                args: ref v96,

            

        

            

                3782
            

            

                
            

            

                
            } => {

            

        

            

                3783
            

            

                
            

            

                
                match v95 {

            

        

            

                3784
            

            

                
            

            

                
                    &Opcode::Select => {

            

        

            

                3785
            

            

                
            

            

                
                        let v97 = C::unpack_value_array_3(ctx, v96);

            

        

            

                3786
            

            

                
            

            

                
                        let v101 = C::inst_data_etor(ctx, v97.0);

            

        

            

                3787
            

            

                
            

            

                
                        let mut v101 = v101;

            

        

            

                3788
            

            

                
            

            

                
                        while let Some(v102) = v101.next(ctx) {

            

        

            

                3789
            

            

                
            

            

                
                            match &v102.1 {

            

        

            

                3790
            

            

                
            

            

                
                                &InstructionData::IntCompare {

            

        

            

                3791
            

            

                
            

            

                
                                    opcode: ref v420,

            

        

            

                3792
            

            

                
            

            

                
                                    args: ref v421,

            

        

            

                3793
            

            

                
            

            

                
                                    cond: ref v422,

            

        

            

                3794
            

            

                
            

            

                
                                } => {

            

        

            

                3795
            

            

                
            

            

                
                                    if let &Opcode::Icmp = v420 {

            

        

            

                3796
            

            

                
            

            

                
                                        match v422 {

            

        

            

                3797
            

            

                
            

            

                
                                            &IntCC::SignedGreaterThan => {

            

        

            

                3798
            

            

                
            

            

                
                                                let v423 = C::unpack_value_array_2(ctx, v421);

            

        

            

                3799
            

            

                
            

            

                
                                                if v97.1 == v423.0 {

            

        

            

                3800
            

            

                
            

            

                
                                                    if v97.2 == v423.1 {

            

        

            

                3801
            

            

                
            

            

                
                                                        let v426 = constructor_smax(

            

        

            

                3802
            

            

                
            

            

                
                                                            ctx, v2.0, v423.0, v423.1,

            

        

            

                3803
            

            

                
            

            

                
                                                        );

            

        

            

                3804
            

            

                
            

            

                
                                                        // Rule at src/opts/selects.isle line 8.

            

        

            

                3805
            

            

                
            

            

                
                                                        returns.push(v426);

            

        

            

                3806
            

            

                
            

            

                
                                                    }

            

        

            

                3807
            

            

                
            

            

                
                                                }

            

        

            

                3808
            

            

                
            

            

                
                                                if v97.1 == v423.1 {

            

        

            

                3809
            

            

                
            

            

                
                                                    if v97.2 == v423.0 {

            

        

            

                3810
            

            

                
            

            

                
                                                        let v428 = constructor_smin(

            

        

            

                3811
            

            

                
            

            

                
                                                            ctx, v2.0, v423.0, v423.1,

            

        

            

                3812
            

            

                
            

            

                
                                                        );

            

        

            

                3813
            

            

                
            

            

                
                                                        // Rule at src/opts/selects.isle line 22.

            

        

            

                3814
            

            

                
            

            

                
                                                        returns.push(v428);

            

        

            

                3815
            

            

                
            

            

                
                                                    }

            

        

            

                3816
            

            

                
            

            

                
                                                }

            

        

            

                3817
            

            

                
            

            

                
                                            }

            

        

            

                3818
            

            

                
            

            

                
                                            &IntCC::SignedGreaterThanOrEqual => {

            

        

            

                3819
            

            

                
            

            

                
                                                let v423 = C::unpack_value_array_2(ctx, v421);

            

        

            

                3820
            

            

                
            

            

                
                                                if v97.1 == v423.0 {

            

        

            

                3821
            

            

                
            

            

                
                                                    if v97.2 == v423.1 {

            

        

            

                3822
            

            

                
            

            

                
                                                        let v426 = constructor_smax(

            

        

            

                3823
            

            

                
            

            

                
                                                            ctx, v2.0, v423.0, v423.1,

            

        

            

                3824
            

            

                
            

            

                
                                                        );

            

        

            

                3825
            

            

                
            

            

                
                                                        // Rule at src/opts/selects.isle line 9.

            

        

            

                3826
            

            

                
            

            

                
                                                        returns.push(v426);

            

        

            

                3827
            

            

                
            

            

                
                                                    }

            

        

            

                3828
            

            

                
            

            

                
                                                }

            

        

            

                3829
            

            

                
            

            

                
                                                if v97.1 == v423.1 {

            

        

            

                3830
            

            

                
            

            

                
                                                    if v97.2 == v423.0 {

            

        

            

                3831
            

            

                
            

            

                
                                                        let v428 = constructor_smin(

            

        

            

                3832
            

            

                
            

            

                
                                                            ctx, v2.0, v423.0, v423.1,

            

        

            

                3833
            

            

                
            

            

                
                                                        );

            

        

            

                3834
            

            

                
            

            

                
                                                        // Rule at src/opts/selects.isle line 23.

            

        

            

                3835
            

            

                
            

            

                
                                                        returns.push(v428);

            

        

            

                3836
            

            

                
            

            

                
                                                    }

            

        

            

                3837
            

            

                
            

            

                
                                                }

            

        

            

                3838
            

            

                
            

            

                
                                            }

            

        

            

                3839
            

            

                
            

            

                
                                            &IntCC::SignedLessThan => {

            

        

            

                3840
            

            

                
            

            

                
                                                let v423 = C::unpack_value_array_2(ctx, v421);

            

        

            

                3841
            

            

                
            

            

                
                                                if v97.1 == v423.0 {

            

        

            

                3842
            

            

                
            

            

                
                                                    if v97.2 == v423.1 {

            

        

            

                3843
            

            

                
            

            

                
                                                        let v428 = constructor_smin(

            

        

            

                3844
            

            

                
            

            

                
                                                            ctx, v2.0, v423.0, v423.1,

            

        

            

                3845
            

            

                
            

            

                
                                                        );

            

        

            

                3846
            

            

                
            

            

                
                                                        // Rule at src/opts/selects.isle line 12.

            

        

            

                3847
            

            

                
            

            

                
                                                        returns.push(v428);

            

        

            

                3848
            

            

                
            

            

                
                                                    }

            

        

            

                3849
            

            

                
            

            

                
                                                }

            

        

            

                3850
            

            

                
            

            

                
                                                if v97.1 == v423.1 {

            

        

            

                3851
            

            

                
            

            

                
                                                    if v97.2 == v423.0 {

            

        

            

                3852
            

            

                
            

            

                
                                                        let v426 = constructor_smax(

            

        

            

                3853
            

            

                
            

            

                
                                                            ctx, v2.0, v423.0, v423.1,

            

        

            

                3854
            

            

                
            

            

                
                                                        );

            

        

            

                3855
            

            

                
            

            

                
                                                        // Rule at src/opts/selects.isle line 18.

            

        

            

                3856
            

            

                
            

            

                
                                                        returns.push(v426);

            

        

            

                3857
            

            

                
            

            

                
                                                    }

            

        

            

                3858
            

            

                
            

            

                
                                                }

            

        

            

                3859
            

            

                
            

            

                
                                            }

            

        

            

                3860
            

            

                
            

            

                
                                            &IntCC::SignedLessThanOrEqual => {

            

        

            

                3861
            

            

                
            

            

                
                                                let v423 = C::unpack_value_array_2(ctx, v421);

            

        

            

                3862
            

            

                
            

            

                
                                                if v97.1 == v423.0 {

            

        

            

                3863
            

            

                
            

            

                
                                                    if v97.2 == v423.1 {

            

        

            

                3864
            

            

                
            

            

                
                                                        let v428 = constructor_smin(

            

        

            

                3865
            

            

                
            

            

                
                                                            ctx, v2.0, v423.0, v423.1,

            

        

            

                3866
            

            

                
            

            

                
                                                        );

            

        

            

                3867
            

            

                
            

            

                
                                                        // Rule at src/opts/selects.isle line 13.

            

        

            

                3868
            

            

                
            

            

                
                                                        returns.push(v428);

            

        

            

                3869
            

            

                
            

            

                
                                                    }

            

        

            

                3870
            

            

                
            

            

                
                                                }

            

        

            

                3871
            

            

                
            

            

                
                                                if v97.1 == v423.1 {

            

        

            

                3872
            

            

                
            

            

                
                                                    if v97.2 == v423.0 {

            

        

            

                3873
            

            

                
            

            

                
                                                        let v426 = constructor_smax(

            

        

            

                3874
            

            

                
            

            

                
                                                            ctx, v2.0, v423.0, v423.1,

            

        

            

                3875
            

            

                
            

            

                
                                                        );

            

        

            

                3876
            

            

                
            

            

                
                                                        // Rule at src/opts/selects.isle line 19.

            

        

            

                3877
            

            

                
            

            

                
                                                        returns.push(v426);

            

        

            

                3878
            

            

                
            

            

                
                                                    }

            

        

            

                3879
            

            

                
            

            

                
                                                }

            

        

            

                3880
            

            

                
            

            

                
                                            }

            

        

            

                3881
            

            

                
            

            

                
                                            &IntCC::UnsignedGreaterThan => {

            

        

            

                3882
            

            

                
            

            

                
                                                let v423 = C::unpack_value_array_2(ctx, v421);

            

        

            

                3883
            

            

                
            

            

                
                                                if v97.1 == v423.0 {

            

        

            

                3884
            

            

                
            

            

                
                                                    if v97.2 == v423.1 {

            

        

            

                3885
            

            

                
            

            

                
                                                        let v427 = constructor_umax(

            

        

            

                3886
            

            

                
            

            

                
                                                            ctx, v2.0, v423.0, v423.1,

            

        

            

                3887
            

            

                
            

            

                
                                                        );

            

        

            

                3888
            

            

                
            

            

                
                                                        // Rule at src/opts/selects.isle line 10.

            

        

            

                3889
            

            

                
            

            

                
                                                        returns.push(v427);

            

        

            

                3890
            

            

                
            

            

                
                                                    }

            

        

            

                3891
            

            

                
            

            

                
                                                }

            

        

            

                3892
            

            

                
            

            

                
                                                if v97.1 == v423.1 {

            

        

            

                3893
            

            

                
            

            

                
                                                    if v97.2 == v423.0 {

            

        

            

                3894
            

            

                
            

            

                
                                                        let v429 = constructor_umin(

            

        

            

                3895
            

            

                
            

            

                
                                                            ctx, v2.0, v423.0, v423.1,

            

        

            

                3896
            

            

                
            

            

                
                                                        );

            

        

            

                3897
            

            

                
            

            

                
                                                        // Rule at src/opts/selects.isle line 24.

            

        

            

                3898
            

            

                
            

            

                
                                                        returns.push(v429);

            

        

            

                3899
            

            

                
            

            

                
                                                    }

            

        

            

                3900
            

            

                
            

            

                
                                                }

            

        

            

                3901
            

            

                
            

            

                
                                            }

            

        

            

                3902
            

            

                
            

            

                
                                            &IntCC::UnsignedGreaterThanOrEqual => {

            

        

            

                3903
            

            

                
            

            

                
                                                let v423 = C::unpack_value_array_2(ctx, v421);

            

        

            

                3904
            

            

                
            

            

                
                                                if v97.1 == v423.0 {

            

        

            

                3905
            

            

                
            

            

                
                                                    if v97.2 == v423.1 {

            

        

            

                3906
            

            

                
            

            

                
                                                        let v427 = constructor_umax(

            

        

            

                3907
            

            

                
            

            

                
                                                            ctx, v2.0, v423.0, v423.1,

            

        

            

                3908
            

            

                
            

            

                
                                                        );

            

        

            

                3909
            

            

                
            

            

                
                                                        // Rule at src/opts/selects.isle line 11.

            

        

            

                3910
            

            

                
            

            

                
                                                        returns.push(v427);

            

        

            

                3911
            

            

                
            

            

                
                                                    }

            

        

            

                3912
            

            

                
            

            

                
                                                }

            

        

            

                3913
            

            

                
            

            

                
                                                if v97.1 == v423.1 {

            

        

            

                3914
            

            

                
            

            

                
                                                    if v97.2 == v423.0 {

            

        

            

                3915
            

            

                
            

            

                
                                                        let v429 = constructor_umin(

            

        

            

                3916
            

            

                
            

            

                
                                                            ctx, v2.0, v423.0, v423.1,

            

        

            

                3917
            

            

                
            

            

                
                                                        );

            

        

            

                3918
            

            

                
            

            

                
                                                        // Rule at src/opts/selects.isle line 25.

            

        

            

                3919
            

            

                
            

            

                
                                                        returns.push(v429);

            

        

            

                3920
            

            

                
            

            

                
                                                    }

            

        

            

                3921
            

            

                
            

            

                
                                                }

            

        

            

                3922
            

            

                
            

            

                
                                            }

            

        

            

                3923
            

            

                
            

            

                
                                            &IntCC::UnsignedLessThan => {

            

        

            

                3924
            

            

                
            

            

                
                                                let v423 = C::unpack_value_array_2(ctx, v421);

            

        

            

                3925
            

            

                
            

            

                
                                                if v97.1 == v423.0 {

            

        

            

                3926
            

            

                
            

            

                
                                                    if v97.2 == v423.1 {

            

        

            

                3927
            

            

                
            

            

                
                                                        let v429 = constructor_umin(

            

        

            

                3928
            

            

                
            

            

                
                                                            ctx, v2.0, v423.0, v423.1,

            

        

            

                3929
            

            

                
            

            

                
                                                        );

            

        

            

                3930
            

            

                
            

            

                
                                                        // Rule at src/opts/selects.isle line 14.

            

        

            

                3931
            

            

                
            

            

                
                                                        returns.push(v429);

            

        

            

                3932
            

            

                
            

            

                
                                                    }

            

        

            

                3933
            

            

                
            

            

                
                                                }

            

        

            

                3934
            

            

                
            

            

                
                                                if v97.1 == v423.1 {

            

        

            

                3935
            

            

                
            

            

                
                                                    if v97.2 == v423.0 {

            

        

            

                3936
            

            

                
            

            

                
                                                        let v427 = constructor_umax(

            

        

            

                3937
            

            

                
            

            

                
                                                            ctx, v2.0, v423.0, v423.1,

            

        

            

                3938
            

            

                
            

            

                
                                                        );

            

        

            

                3939
            

            

                
            

            

                
                                                        // Rule at src/opts/selects.isle line 20.

            

        

            

                3940
            

            

                
            

            

                
                                                        returns.push(v427);

            

        

            

                3941
            

            

                
            

            

                
                                                    }

            

        

            

                3942
            

            

                
            

            

                
                                                }

            

        

            

                3943
            

            

                
            

            

                
                                            }

            

        

            

                3944
            

            

                
            

            

                
                                            &IntCC::UnsignedLessThanOrEqual => {

            

        

            

                3945
            

            

                
            

            

                
                                                let v423 = C::unpack_value_array_2(ctx, v421);

            

        

            

                3946
            

            

                
            

            

                
                                                if v97.1 == v423.0 {

            

        

            

                3947
            

            

                
            

            

                
                                                    if v97.2 == v423.1 {

            

        

            

                3948
            

            

                
            

            

                
                                                        let v429 = constructor_umin(

            

        

            

                3949
            

            

                
            

            

                
                                                            ctx, v2.0, v423.0, v423.1,

            

        

            

                3950
            

            

                
            

            

                
                                                        );

            

        

            

                3951
            

            

                
            

            

                
                                                        // Rule at src/opts/selects.isle line 15.

            

        

            

                3952
            

            

                
            

            

                
                                                        returns.push(v429);

            

        

            

                3953
            

            

                
            

            

                
                                                    }

            

        

            

                3954
            

            

                
            

            

                
                                                }

            

        

            

                3955
            

            

                
            

            

                
                                                if v97.1 == v423.1 {

            

        

            

                3956
            

            

                
            

            

                
                                                    if v97.2 == v423.0 {

            

        

            

                3957
            

            

                
            

            

                
                                                        let v427 = constructor_umax(

            

        

            

                3958
            

            

                
            

            

                
                                                            ctx, v2.0, v423.0, v423.1,

            

        

            

                3959
            

            

                
            

            

                
                                                        );

            

        

            

                3960
            

            

                
            

            

                
                                                        // Rule at src/opts/selects.isle line 21.

            

        

            

                3961
            

            

                
            

            

                
                                                        returns.push(v427);

            

        

            

                3962
            

            

                
            

            

                
                                                    }

            

        

            

                3963
            

            

                
            

            

                
                                                }

            

        

            

                3964
            

            

                
            

            

                
                                            }

            

        

            

                3965
            

            

                
            

            

                
                                            _ => {}

            

        

            

                3966
            

            

                
            

            

                
                                        }

            

        

            

                3967
            

            

                
            

            

                
                                    }

            

        

            

                3968
            

            

                
            

            

                
                                }

            

        

            

                3969
            

            

                
            

            

                
                                &InstructionData::Unary {

            

        

            

                3970
            

            

                
            

            

                
                                    opcode: ref v105,

            

        

            

                3971
            

            

                
            

            

                
                                    arg: v106,

            

        

            

                3972
            

            

                
            

            

                
                                } => {

            

        

            

                3973
            

            

                
            

            

                
                                    if let &Opcode::Uextend = v105 {

            

        

            

                3974
            

            

                
            

            

                
                                        let v361 = C::inst_data_etor(ctx, v106);

            

        

            

                3975
            

            

                
            

            

                
                                        let mut v361 = v361;

            

        

            

                3976
            

            

                
            

            

                
                                        while let Some(v362) = v361.next(ctx) {

            

        

            

                3977
            

            

                
            

            

                
                                            if let &InstructionData::IntCompare {

            

        

            

                3978
            

            

                
            

            

                
                                                opcode: ref v365,

            

        

            

                3979
            

            

                
            

            

                
                                                args: ref v366,

            

        

            

                3980
            

            

                
            

            

                
                                                cond: ref v367,

            

        

            

                3981
            

            

                
            

            

                
                                            } = &v362.1

            

        

            

                3982
            

            

                
            

            

                
                                            {

            

        

            

                3983
            

            

                
            

            

                
                                                if let &Opcode::Icmp = v365 {

            

        

            

                3984
            

            

                
            

            

                
                                                    let v371 = constructor_select(

            

        

            

                3985
            

            

                
            

            

                
                                                        ctx, v2.0, v106, v97.1, v97.2,

            

        

            

                3986
            

            

                
            

            

                
                                                    );

            

        

            

                3987
            

            

                
            

            

                
                                                    // Rule at src/opts/icmp.isle line 29.

            

        

            

                3988
            

            

                
            

            

                
                                                    returns.push(v371);

            

        

            

                3989
            

            

                
            

            

                
                                                    // Rule at src/opts/icmp.isle line 32.

            

        

            

                3990
            

            

                
            

            

                
                                                    returns.push(v371);

            

        

            

                3991
            

            

                
            

            

                
                                                }

            

        

            

                3992
            

            

                
            

            

                
                                            }

            

        

            

                3993
            

            

                
            

            

                
                                        }

            

        

            

                3994
            

            

                
            

            

                
                                    }

            

        

            

                3995
            

            

                
            

            

                
                                }

            

        

            

                3996
            

            

                
            

            

                
                                &InstructionData::UnaryImm {

            

        

            

                3997
            

            

                
            

            

                
                                    opcode: ref v300,

            

        

            

                3998
            

            

                
            

            

                
                                    imm: v301,

            

        

            

                3999
            

            

                
            

            

                
                                } => {

            

        

            

                4000
            

            

                
            

            

                
                                    if let &Opcode::Iconst = v300 {

            

        

            

                4001
            

            

                
            

            

                
                                        let v302 = C::u64_from_imm64(ctx, v301);

            

        

            

                4002
            

            

                
            

            

                
                                        if v302 == 0x0 {

            

        

            

                4003
            

            

                
            

            

                
                                            // Rule at src/opts/cprop.isle line 172.

            

        

            

                4004
            

            

                
            

            

                
                                            returns.push(v97.2);

            

        

            

                4005
            

            

                
            

            

                
                                        }

            

        

            

                4006
            

            

                
            

            

                
                                        let v303 = C::u64_is_zero(ctx, v302);

            

        

            

                4007
            

            

                
            

            

                
                                        if v303 == false {

            

        

            

                4008
            

            

                
            

            

                
                                            // Rule at src/opts/cprop.isle line 169.

            

        

            

                4009
            

            

                
            

            

                
                                            returns.push(v97.1);

            

        

            

                4010
            

            

                
            

            

                
                                        }

            

        

            

                4011
            

            

                
            

            

                
                                    }

            

        

            

                4012
            

            

                
            

            

                
                                }

            

        

            

                4013
            

            

                
            

            

                
                                _ => {}

            

        

            

                4014
            

            

                
            

            

                
                            }

            

        

            

                4015
            

            

                
            

            

                
                        }

            

        

            

                4016
            

            

                
            

            

                
                        if v97.1 == v97.2 {

            

        

            

                4017
            

            

                
            

            

                
                            // Rule at src/opts/selects.isle line 4.

            

        

            

                4018
            

            

                
            

            

                
                            returns.push(v97.1);

            

        

            

                4019
            

            

                
            

            

                
                        }

            

        

            

                4020
            

            

                
            

            

                
                        let v166 = constructor_truthy(ctx, v97.0);

            

        

            

                4021
            

            

                
            

            

                
                        let mut v166 = v166;

            

        

            

                4022
            

            

                
            

            

                
                        while let Some(v167) = v166.next(ctx) {

            

        

            

                4023
            

            

                
            

            

                
                            let v168 = constructor_select(ctx, v2.0, v167, v97.1, v97.2);

            

        

            

                4024
            

            

                
            

            

                
                            // Rule at src/opts/bitops.isle line 128.

            

        

            

                4025
            

            

                
            

            

                
                            returns.push(v168);

            

        

            

                4026
            

            

                
            

            

                
                        }

            

        

            

                4027
            

            

                
            

            

                
                    }

            

        

            

                4028
            

            

                
            

            

                
                    &Opcode::Bitselect => {

            

        

            

                4029
            

            

                
            

            

                
                        let v430 = C::multi_lane(ctx, v2.0);

            

        

            

                4030
            

            

                
            

            

                
                        if let Some(v431) = v430 {

            

        

            

                4031
            

            

                
            

            

                
                            let v97 = C::unpack_value_array_3(ctx, v96);

            

        

            

                4032
            

            

                
            

            

                
                            let v101 = C::inst_data_etor(ctx, v97.0);

            

        

            

                4033
            

            

                
            

            

                
                            let mut v101 = v101;

            

        

            

                4034
            

            

                
            

            

                
                            while let Some(v102) = v101.next(ctx) {

            

        

            

                4035
            

            

                
            

            

                
                                if let &InstructionData::IntCompare {

            

        

            

                4036
            

            

                
            

            

                
                                    opcode: ref v420,

            

        

            

                4037
            

            

                
            

            

                
                                    args: ref v421,

            

        

            

                4038
            

            

                
            

            

                
                                    cond: ref v422,

            

        

            

                4039
            

            

                
            

            

                
                                } = &v102.1

            

        

            

                4040
            

            

                
            

            

                
                                {

            

        

            

                4041
            

            

                
            

            

                
                                    if let &Opcode::Icmp = v420 {

            

        

            

                4042
            

            

                
            

            

                
                                        match v422 {

            

        

            

                4043
            

            

                
            

            

                
                                            &IntCC::SignedGreaterThan => {

            

        

            

                4044
            

            

                
            

            

                
                                                let v423 = C::unpack_value_array_2(ctx, v421);

            

        

            

                4045
            

            

                
            

            

                
                                                if v97.1 == v423.0 {

            

        

            

                4046
            

            

                
            

            

                
                                                    if v97.2 == v423.1 {

            

        

            

                4047
            

            

                
            

            

                
                                                        let v426 = constructor_smax(

            

        

            

                4048
            

            

                
            

            

                
                                                            ctx, v2.0, v423.0, v423.1,

            

        

            

                4049
            

            

                
            

            

                
                                                        );

            

        

            

                4050
            

            

                
            

            

                
                                                        // Rule at src/opts/selects.isle line 28.

            

        

            

                4051
            

            

                
            

            

                
                                                        returns.push(v426);

            

        

            

                4052
            

            

                
            

            

                
                                                    }

            

        

            

                4053
            

            

                
            

            

                
                                                }

            

        

            

                4054
            

            

                
            

            

                
                                                if v97.1 == v423.1 {

            

        

            

                4055
            

            

                
            

            

                
                                                    if v97.2 == v423.0 {

            

        

            

                4056
            

            

                
            

            

                
                                                        let v428 = constructor_smin(

            

        

            

                4057
            

            

                
            

            

                
                                                            ctx, v2.0, v423.0, v423.1,

            

        

            

                4058
            

            

                
            

            

                
                                                        );

            

        

            

                4059
            

            

                
            

            

                
                                                        // Rule at src/opts/selects.isle line 42.

            

        

            

                4060
            

            

                
            

            

                
                                                        returns.push(v428);

            

        

            

                4061
            

            

                
            

            

                
                                                    }

            

        

            

                4062
            

            

                
            

            

                
                                                }

            

        

            

                4063
            

            

                
            

            

                
                                            }

            

        

            

                4064
            

            

                
            

            

                
                                            &IntCC::SignedGreaterThanOrEqual => {

            

        

            

                4065
            

            

                
            

            

                
                                                let v423 = C::unpack_value_array_2(ctx, v421);

            

        

            

                4066
            

            

                
            

            

                
                                                if v97.1 == v423.0 {

            

        

            

                4067
            

            

                
            

            

                
                                                    if v97.2 == v423.1 {

            

        

            

                4068
            

            

                
            

            

                
                                                        let v426 = constructor_smax(

            

        

            

                4069
            

            

                
            

            

                
                                                            ctx, v2.0, v423.0, v423.1,

            

        

            

                4070
            

            

                
            

            

                
                                                        );

            

        

            

                4071
            

            

                
            

            

                
                                                        // Rule at src/opts/selects.isle line 29.

            

        

            

                4072
            

            

                
            

            

                
                                                        returns.push(v426);

            

        

            

                4073
            

            

                
            

            

                
                                                    }

            

        

            

                4074
            

            

                
            

            

                
                                                }

            

        

            

                4075
            

            

                
            

            

                
                                                if v97.1 == v423.1 {

            

        

            

                4076
            

            

                
            

            

                
                                                    if v97.2 == v423.0 {

            

        

            

                4077
            

            

                
            

            

                
                                                        let v428 = constructor_smin(

            

        

            

                4078
            

            

                
            

            

                
                                                            ctx, v2.0, v423.0, v423.1,

            

        

            

                4079
            

            

                
            

            

                
                                                        );

            

        

            

                4080
            

            

                
            

            

                
                                                        // Rule at src/opts/selects.isle line 43.

            

        

            

                4081
            

            

                
            

            

                
                                                        returns.push(v428);

            

        

            

                4082
            

            

                
            

            

                
                                                    }

            

        

            

                4083
            

            

                
            

            

                
                                                }

            

        

            

                4084
            

            

                
            

            

                
                                            }

            

        

            

                4085
            

            

                
            

            

                
                                            &IntCC::SignedLessThan => {

            

        

            

                4086
            

            

                
            

            

                
                                                let v423 = C::unpack_value_array_2(ctx, v421);

            

        

            

                4087
            

            

                
            

            

                
                                                if v97.1 == v423.0 {

            

        

            

                4088
            

            

                
            

            

                
                                                    if v97.2 == v423.1 {

            

        

            

                4089
            

            

                
            

            

                
                                                        let v428 = constructor_smin(

            

        

            

                4090
            

            

                
            

            

                
                                                            ctx, v2.0, v423.0, v423.1,

            

        

            

                4091
            

            

                
            

            

                
                                                        );

            

        

            

                4092
            

            

                
            

            

                
                                                        // Rule at src/opts/selects.isle line 32.

            

        

            

                4093
            

            

                
            

            

                
                                                        returns.push(v428);

            

        

            

                4094
            

            

                
            

            

                
                                                    }

            

        

            

                4095
            

            

                
            

            

                
                                                }

            

        

            

                4096
            

            

                
            

            

                
                                                if v97.1 == v423.1 {

            

        

            

                4097
            

            

                
            

            

                
                                                    if v97.2 == v423.0 {

            

        

            

                4098
            

            

                
            

            

                
                                                        let v426 = constructor_smax(

            

        

            

                4099
            

            

                
            

            

                
                                                            ctx, v2.0, v423.0, v423.1,

            

        

            

                4100
            

            

                
            

            

                
                                                        );

            

        

            

                4101
            

            

                
            

            

                
                                                        // Rule at src/opts/selects.isle line 38.

            

        

            

                4102
            

            

                
            

            

                
                                                        returns.push(v426);

            

        

            

                4103
            

            

                
            

            

                
                                                    }

            

        

            

                4104
            

            

                
            

            

                
                                                }

            

        

            

                4105
            

            

                
            

            

                
                                            }

            

        

            

                4106
            

            

                
            

            

                
                                            &IntCC::SignedLessThanOrEqual => {

            

        

            

                4107
            

            

                
            

            

                
                                                let v423 = C::unpack_value_array_2(ctx, v421);

            

        

            

                4108
            

            

                
            

            

                
                                                if v97.1 == v423.0 {

            

        

            

                4109
            

            

                
            

            

                
                                                    if v97.2 == v423.1 {

            

        

            

                4110
            

            

                
            

            

                
                                                        let v428 = constructor_smin(

            

        

            

                4111
            

            

                
            

            

                
                                                            ctx, v2.0, v423.0, v423.1,

            

        

            

                4112
            

            

                
            

            

                
                                                        );

            

        

            

                4113
            

            

                
            

            

                
                                                        // Rule at src/opts/selects.isle line 33.

            

        

            

                4114
            

            

                
            

            

                
                                                        returns.push(v428);

            

        

            

                4115
            

            

                
            

            

                
                                                    }

            

        

            

                4116
            

            

                
            

            

                
                                                }

            

        

            

                4117
            

            

                
            

            

                
                                                if v97.1 == v423.1 {

            

        

            

                4118
            

            

                
            

            

                
                                                    if v97.2 == v423.0 {

            

        

            

                4119
            

            

                
            

            

                
                                                        let v426 = constructor_smax(

            

        

            

                4120
            

            

                
            

            

                
                                                            ctx, v2.0, v423.0, v423.1,

            

        

            

                4121
            

            

                
            

            

                
                                                        );

            

        

            

                4122
            

            

                
            

            

                
                                                        // Rule at src/opts/selects.isle line 39.

            

        

            

                4123
            

            

                
            

            

                
                                                        returns.push(v426);

            

        

            

                4124
            

            

                
            

            

                
                                                    }

            

        

            

                4125
            

            

                
            

            

                
                                                }

            

        

            

                4126
            

            

                
            

            

                
                                            }

            

        

            

                4127
            

            

                
            

            

                
                                            &IntCC::UnsignedGreaterThan => {

            

        

            

                4128
            

            

                
            

            

                
                                                let v423 = C::unpack_value_array_2(ctx, v421);

            

        

            

                4129
            

            

                
            

            

                
                                                if v97.1 == v423.0 {

            

        

            

                4130
            

            

                
            

            

                
                                                    if v97.2 == v423.1 {

            

        

            

                4131
            

            

                
            

            

                
                                                        let v427 = constructor_umax(

            

        

            

                4132
            

            

                
            

            

                
                                                            ctx, v2.0, v423.0, v423.1,

            

        

            

                4133
            

            

                
            

            

                
                                                        );

            

        

            

                4134
            

            

                
            

            

                
                                                        // Rule at src/opts/selects.isle line 30.

            

        

            

                4135
            

            

                
            

            

                
                                                        returns.push(v427);

            

        

            

                4136
            

            

                
            

            

                
                                                    }

            

        

            

                4137
            

            

                
            

            

                
                                                }

            

        

            

                4138
            

            

                
            

            

                
                                                if v97.1 == v423.1 {

            

        

            

                4139
            

            

                
            

            

                
                                                    if v97.2 == v423.0 {

            

        

            

                4140
            

            

                
            

            

                
                                                        let v429 = constructor_umin(

            

        

            

                4141
            

            

                
            

            

                
                                                            ctx, v2.0, v423.0, v423.1,

            

        

            

                4142
            

            

                
            

            

                
                                                        );

            

        

            

                4143
            

            

                
            

            

                
                                                        // Rule at src/opts/selects.isle line 44.

            

        

            

                4144
            

            

                
            

            

                
                                                        returns.push(v429);

            

        

            

                4145
            

            

                
            

            

                
                                                    }

            

        

            

                4146
            

            

                
            

            

                
                                                }

            

        

            

                4147
            

            

                
            

            

                
                                            }

            

        

            

                4148
            

            

                
            

            

                
                                            &IntCC::UnsignedGreaterThanOrEqual => {

            

        

            

                4149
            

            

                
            

            

                
                                                let v423 = C::unpack_value_array_2(ctx, v421);

            

        

            

                4150
            

            

                
            

            

                
                                                if v97.1 == v423.0 {

            

        

            

                4151
            

            

                
            

            

                
                                                    if v97.2 == v423.1 {

            

        

            

                4152
            

            

                
            

            

                
                                                        let v427 = constructor_umax(

            

        

            

                4153
            

            

                
            

            

                
                                                            ctx, v2.0, v423.0, v423.1,

            

        

            

                4154
            

            

                
            

            

                
                                                        );

            

        

            

                4155
            

            

                
            

            

                
                                                        // Rule at src/opts/selects.isle line 31.

            

        

            

                4156
            

            

                
            

            

                
                                                        returns.push(v427);

            

        

            

                4157
            

            

                
            

            

                
                                                    }

            

        

            

                4158
            

            

                
            

            

                
                                                }

            

        

            

                4159
            

            

                
            

            

                
                                                if v97.1 == v423.1 {

            

        

            

                4160
            

            

                
            

            

                
                                                    if v97.2 == v423.0 {

            

        

            

                4161
            

            

                
            

            

                
                                                        let v429 = constructor_umin(

            

        

            

                4162
            

            

                
            

            

                
                                                            ctx, v2.0, v423.0, v423.1,

            

        

            

                4163
            

            

                
            

            

                
                                                        );

            

        

            

                4164
            

            

                
            

            

                
                                                        // Rule at src/opts/selects.isle line 45.

            

        

            

                4165
            

            

                
            

            

                
                                                        returns.push(v429);

            

        

            

                4166
            

            

                
            

            

                
                                                    }

            

        

            

                4167
            

            

                
            

            

                
                                                }

            

        

            

                4168
            

            

                
            

            

                
                                            }

            

        

            

                4169
            

            

                
            

            

                
                                            &IntCC::UnsignedLessThan => {

            

        

            

                4170
            

            

                
            

            

                
                                                let v423 = C::unpack_value_array_2(ctx, v421);

            

        

            

                4171
            

            

                
            

            

                
                                                if v97.1 == v423.0 {

            

        

            

                4172
            

            

                
            

            

                
                                                    if v97.2 == v423.1 {

            

        

            

                4173
            

            

                
            

            

                
                                                        let v429 = constructor_umin(

            

        

            

                4174
            

            

                
            

            

                
                                                            ctx, v2.0, v423.0, v423.1,

            

        

            

                4175
            

            

                
            

            

                
                                                        );

            

        

            

                4176
            

            

                
            

            

                
                                                        // Rule at src/opts/selects.isle line 34.

            

        

            

                4177
            

            

                
            

            

                
                                                        returns.push(v429);

            

        

            

                4178
            

            

                
            

            

                
                                                    }

            

        

            

                4179
            

            

                
            

            

                
                                                }

            

        

            

                4180
            

            

                
            

            

                
                                                if v97.1 == v423.1 {

            

        

            

                4181
            

            

                
            

            

                
                                                    if v97.2 == v423.0 {

            

        

            

                4182
            

            

                
            

            

                
                                                        let v427 = constructor_umax(

            

        

            

                4183
            

            

                
            

            

                
                                                            ctx, v2.0, v423.0, v423.1,

            

        

            

                4184
            

            

                
            

            

                
                                                        );

            

        

            

                4185
            

            

                
            

            

                
                                                        // Rule at src/opts/selects.isle line 40.

            

        

            

                4186
            

            

                
            

            

                
                                                        returns.push(v427);

            

        

            

                4187
            

            

                
            

            

                
                                                    }

            

        

            

                4188
            

            

                
            

            

                
                                                }

            

        

            

                4189
            

            

                
            

            

                
                                            }

            

        

            

                4190
            

            

                
            

            

                
                                            &IntCC::UnsignedLessThanOrEqual => {

            

        

            

                4191
            

            

                
            

            

                
                                                let v423 = C::unpack_value_array_2(ctx, v421);

            

        

            

                4192
            

            

                
            

            

                
                                                if v97.1 == v423.0 {

            

        

            

                4193
            

            

                
            

            

                
                                                    if v97.2 == v423.1 {

            

        

            

                4194
            

            

                
            

            

                
                                                        let v429 = constructor_umin(

            

        

            

                4195
            

            

                
            

            

                
                                                            ctx, v2.0, v423.0, v423.1,

            

        

            

                4196
            

            

                
            

            

                
                                                        );

            

        

            

                4197
            

            

                
            

            

                
                                                        // Rule at src/opts/selects.isle line 35.

            

        

            

                4198
            

            

                
            

            

                
                                                        returns.push(v429);

            

        

            

                4199
            

            

                
            

            

                
                                                    }

            

        

            

                4200
            

            

                
            

            

                
                                                }

            

        

            

                4201
            

            

                
            

            

                
                                                if v97.1 == v423.1 {

            

        

            

                4202
            

            

                
            

            

                
                                                    if v97.2 == v423.0 {

            

        

            

                4203
            

            

                
            

            

                
                                                        let v427 = constructor_umax(

            

        

            

                4204
            

            

                
            

            

                
                                                            ctx, v2.0, v423.0, v423.1,

            

        

            

                4205
            

            

                
            

            

                
                                                        );

            

        

            

                4206
            

            

                
            

            

                
                                                        // Rule at src/opts/selects.isle line 41.

            

        

            

                4207
            

            

                
            

            

                
                                                        returns.push(v427);

            

        

            

                4208
            

            

                
            

            

                
                                                    }

            

        

            

                4209
            

            

                
            

            

                
                                                }

            

        

            

                4210
            

            

                
            

            

                
                                            }

            

        

            

                4211
            

            

                
            

            

                
                                            _ => {}

            

        

            

                4212
            

            

                
            

            

                
                                        }

            

        

            

                4213
            

            

                
            

            

                
                                    }

            

        

            

                4214
            

            

                
            

            

                
                                }

            

        

            

                4215
            

            

                
            

            

                
                            }

            

        

            

                4216
            

            

                
            

            

                
                        }

            

        

            

                4217
            

            

                
            

            

                
                        let v97 = C::unpack_value_array_3(ctx, v96);

            

        

            

                4218
            

            

                
            

            

                
                        if v97.1 == v97.2 {

            

        

            

                4219
            

            

                
            

            

                
                            // Rule at src/opts/selects.isle line 5.

            

        

            

                4220
            

            

                
            

            

                
                            returns.push(v97.1);

            

        

            

                4221
            

            

                
            

            

                
                        }

            

        

            

                4222
            

            

                
            

            

                
                    }

            

        

            

                4223
            

            

                
            

            

                
                    &Opcode::Fma => {

            

        

            

                4224
            

            

                
            

            

                
                        let v97 = C::unpack_value_array_3(ctx, v96);

            

        

            

                4225
            

            

                
            

            

                
                        let v101 = C::inst_data_etor(ctx, v97.0);

            

        

            

                4226
            

            

                
            

            

                
                        let mut v101 = v101;

            

        

            

                4227
            

            

                
            

            

                
                        while let Some(v102) = v101.next(ctx) {

            

        

            

                4228
            

            

                
            

            

                
                            if let &InstructionData::Unary {

            

        

            

                4229
            

            

                
            

            

                
                                opcode: ref v105,

            

        

            

                4230
            

            

                
            

            

                
                                arg: v106,

            

        

            

                4231
            

            

                
            

            

                
                            } = &v102.1

            

        

            

                4232
            

            

                
            

            

                
                            {

            

        

            

                4233
            

            

                
            

            

                
                                if let &Opcode::Fneg = v105 {

            

        

            

                4234
            

            

                
            

            

                
                                    if v2.0 == v102.0 {

            

        

            

                4235
            

            

                
            

            

                
                                        let v107 = C::inst_data_etor(ctx, v97.1);

            

        

            

                4236
            

            

                
            

            

                
                                        let mut v107 = v107;

            

        

            

                4237
            

            

                
            

            

                
                                        while let Some(v108) = v107.next(ctx) {

            

        

            

                4238
            

            

                
            

            

                
                                            if let &InstructionData::Unary {

            

        

            

                4239
            

            

                
            

            

                
                                                opcode: ref v111,

            

        

            

                4240
            

            

                
            

            

                
                                                arg: v112,

            

        

            

                4241
            

            

                
            

            

                
                                            } = &v108.1

            

        

            

                4242
            

            

                
            

            

                
                                            {

            

        

            

                4243
            

            

                
            

            

                
                                                if let &Opcode::Fneg = v111 {

            

        

            

                4244
            

            

                
            

            

                
                                                    if v2.0 == v108.0 {

            

        

            

                4245
            

            

                
            

            

                
                                                        let v113 = constructor_fma(

            

        

            

                4246
            

            

                
            

            

                
                                                            ctx, v2.0, v106, v112, v97.2,

            

        

            

                4247
            

            

                
            

            

                
                                                        );

            

        

            

                4248
            

            

                
            

            

                
                                                        // Rule at src/opts/arithmetic.isle line 122.

            

        

            

                4249
            

            

                
            

            

                
                                                        returns.push(v113);

            

        

            

                4250
            

            

                
            

            

                
                                                    }

            

        

            

                4251
            

            

                
            

            

                
                                                }

            

        

            

                4252
            

            

                
            

            

                
                                            }

            

        

            

                4253
            

            

                
            

            

                
                                        }

            

        

            

                4254
            

            

                
            

            

                
                                    }

            

        

            

                4255
            

            

                
            

            

                
                                }

            

        

            

                4256
            

            

                
            

            

                
                            }

            

        

            

                4257
            

            

                
            

            

                
                        }

            

        

            

                4258
            

            

                
            

            

                
                    }

            

        

            

                4259
            

            

                
            

            

                
                    _ => {}

            

        

            

                4260
            

            

                
            

            

                
                }

            

        

            

                4261
            

            

                
            

            

                
            }

            

        

            

                4262
            

            

                
            

            

                
            &InstructionData::Unary {

            

        

            

                4263
            

            

                
            

            

                
                opcode: ref v27,

            

        

            

                4264
            

            

                
            

            

                
                arg: v28,

            

        

            

                4265
            

            

                
            

            

                
            } => {

            

        

            

                4266
            

            

                
            

            

                
                match v27 {

            

        

            

                4267
            

            

                
            

            

                
                    &Opcode::Splat => {

            

        

            

                4268
            

            

                
            

            

                
                        let v29 = C::inst_data_etor(ctx, v28);

            

        

            

                4269
            

            

                
            

            

                
                        let mut v29 = v29;

            

        

            

                4270
            

            

                
            

            

                
                        while let Some(v30) = v29.next(ctx) {

            

        

            

                4271
            

            

                
            

            

                
                            match &v30.1 {

            

        

            

                4272
            

            

                
            

            

                
                                &InstructionData::UnaryIeee32 {

            

        

            

                4273
            

            

                
            

            

                
                                    opcode: ref v320,

            

        

            

                4274
            

            

                
            

            

                
                                    imm: v321,

            

        

            

                4275
            

            

                
            

            

                
                                } => {

            

        

            

                4276
            

            

                
            

            

                
                                    if let &Opcode::F32const = v320 {

            

        

            

                4277
            

            

                
            

            

                
                                        let v322 = C::u32_from_ieee32(ctx, v321);

            

        

            

                4278
            

            

                
            

            

                
                                        let v323 = C::u32_as_u64(ctx, v322);

            

        

            

                4279
            

            

                
            

            

                
                                        let v324 = constructor_splat32(ctx, v323);

            

        

            

                4280
            

            

                
            

            

                
                                        let v325 = constructor_vconst(ctx, v2.0, v324);

            

        

            

                4281
            

            

                
            

            

                
                                        // Rule at src/opts/cprop.isle line 188.

            

        

            

                4282
            

            

                
            

            

                
                                        returns.push(v325);

            

        

            

                4283
            

            

                
            

            

                
                                    }

            

        

            

                4284
            

            

                
            

            

                
                                }

            

        

            

                4285
            

            

                
            

            

                
                                &InstructionData::UnaryIeee64 {

            

        

            

                4286
            

            

                
            

            

                
                                    opcode: ref v326,

            

        

            

                4287
            

            

                
            

            

                
                                    imm: v327,

            

        

            

                4288
            

            

                
            

            

                
                                } => {

            

        

            

                4289
            

            

                
            

            

                
                                    if let &Opcode::F64const = v326 {

            

        

            

                4290
            

            

                
            

            

                
                                        let v328 = C::u64_from_ieee64(ctx, v327);

            

        

            

                4291
            

            

                
            

            

                
                                        let v329 = C::splat64(ctx, v328);

            

        

            

                4292
            

            

                
            

            

                
                                        let v330 = constructor_vconst(ctx, v2.0, v329);

            

        

            

                4293
            

            

                
            

            

                
                                        // Rule at src/opts/cprop.isle line 190.

            

        

            

                4294
            

            

                
            

            

                
                                        returns.push(v330);

            

        

            

                4295
            

            

                
            

            

                
                                    }

            

        

            

                4296
            

            

                
            

            

                
                                }

            

        

            

                4297
            

            

                
            

            

                
                                &InstructionData::UnaryImm {

            

        

            

                4298
            

            

                
            

            

                
                                    opcode: ref v222,

            

        

            

                4299
            

            

                
            

            

                
                                    imm: v223,

            

        

            

                4300
            

            

                
            

            

                
                                } => {

            

        

            

                4301
            

            

                
            

            

                
                                    if let &Opcode::Iconst = v222 {

            

        

            

                4302
            

            

                
            

            

                
                                        match v30.0 {

            

        

            

                4303
            

            

                
            

            

                
                                            I8 => {

            

        

            

                4304
            

            

                
            

            

                
                                                let v305 = C::u64_uextend_imm64(ctx, I8, v223);

            

        

            

                4305
            

            

                
            

            

                
                                                let v306 = constructor_splat8(ctx, v305);

            

        

            

                4306
            

            

                
            

            

                
                                                let v307 = constructor_vconst(ctx, v2.0, v306);

            

        

            

                4307
            

            

                
            

            

                
                                                // Rule at src/opts/cprop.isle line 180.

            

        

            

                4308
            

            

                
            

            

                
                                                returns.push(v307);

            

        

            

                4309
            

            

                
            

            

                
                                            }

            

        

            

                4310
            

            

                
            

            

                
                                            I16 => {

            

        

            

                4311
            

            

                
            

            

                
                                                let v309 = C::u64_uextend_imm64(ctx, I16, v223);

            

        

            

                4312
            

            

                
            

            

                
                                                let v310 = constructor_splat16(ctx, v309);

            

        

            

                4313
            

            

                
            

            

                
                                                let v311 = constructor_vconst(ctx, v2.0, v310);

            

        

            

                4314
            

            

                
            

            

                
                                                // Rule at src/opts/cprop.isle line 182.

            

        

            

                4315
            

            

                
            

            

                
                                                returns.push(v311);

            

        

            

                4316
            

            

                
            

            

                
                                            }

            

        

            

                4317
            

            

                
            

            

                
                                            I32 => {

            

        

            

                4318
            

            

                
            

            

                
                                                let v313 = C::u64_uextend_imm64(ctx, I32, v223);

            

        

            

                4319
            

            

                
            

            

                
                                                let v314 = constructor_splat32(ctx, v313);

            

        

            

                4320
            

            

                
            

            

                
                                                let v315 = constructor_vconst(ctx, v2.0, v314);

            

        

            

                4321
            

            

                
            

            

                
                                                // Rule at src/opts/cprop.isle line 184.

            

        

            

                4322
            

            

                
            

            

                
                                                returns.push(v315);

            

        

            

                4323
            

            

                
            

            

                
                                            }

            

        

            

                4324
            

            

                
            

            

                
                                            I64 => {

            

        

            

                4325
            

            

                
            

            

                
                                                let v317 = C::u64_uextend_imm64(ctx, I64, v223);

            

        

            

                4326
            

            

                
            

            

                
                                                let v318 = C::splat64(ctx, v317);

            

        

            

                4327
            

            

                
            

            

                
                                                let v319 = constructor_vconst(ctx, v2.0, v318);

            

        

            

                4328
            

            

                
            

            

                
                                                // Rule at src/opts/cprop.isle line 186.

            

        

            

                4329
            

            

                
            

            

                
                                                returns.push(v319);

            

        

            

                4330
            

            

                
            

            

                
                                            }

            

        

            

                4331
            

            

                
            

            

                
                                            _ => {}

            

        

            

                4332
            

            

                
            

            

                
                                        }

            

        

            

                4333
            

            

                
            

            

                
                                    }

            

        

            

                4334
            

            

                
            

            

                
                                }

            

        

            

                4335
            

            

                
            

            

                
                                _ => {}

            

        

            

                4336
            

            

                
            

            

                
                            }

            

        

            

                4337
            

            

                
            

            

                
                        }

            

        

            

                4338
            

            

                
            

            

                
                    }

            

        

            

                4339
            

            

                
            

            

                
                    &Opcode::Ineg => {

            

        

            

                4340
            

            

                
            

            

                
                        let v29 = C::inst_data_etor(ctx, v28);

            

        

            

                4341
            

            

                
            

            

                
                        let mut v29 = v29;

            

        

            

                4342
            

            

                
            

            

                
                        while let Some(v30) = v29.next(ctx) {

            

        

            

                4343
            

            

                
            

            

                
                            match &v30.1 {

            

        

            

                4344
            

            

                
            

            

                
                                &InstructionData::Binary {

            

        

            

                4345
            

            

                
            

            

                
                                    opcode: ref v57,

            

        

            

                4346
            

            

                
            

            

                
                                    args: ref v58,

            

        

            

                4347
            

            

                
            

            

                
                                } => {

            

        

            

                4348
            

            

                
            

            

                
                                    if let &Opcode::Ushr = v57 {

            

        

            

                4349
            

            

                
            

            

                
                                        if v2.0 == v30.0 {

            

        

            

                4350
            

            

                
            

            

                
                                            let v59 = C::unpack_value_array_2(ctx, v58);

            

        

            

                4351
            

            

                
            

            

                
                                            let v62 = C::inst_data_etor(ctx, v59.1);

            

        

            

                4352
            

            

                
            

            

                
                                            let mut v62 = v62;

            

        

            

                4353
            

            

                
            

            

                
                                            while let Some(v63) = v62.next(ctx) {

            

        

            

                4354
            

            

                
            

            

                
                                                if let &InstructionData::UnaryImm {

            

        

            

                4355
            

            

                
            

            

                
                                                    opcode: ref v66,

            

        

            

                4356
            

            

                
            

            

                
                                                    imm: v67,

            

        

            

                4357
            

            

                
            

            

                
                                                } = &v63.1

            

        

            

                4358
            

            

                
            

            

                
                                                {

            

        

            

                4359
            

            

                
            

            

                
                                                    if let &Opcode::Iconst = v66 {

            

        

            

                4360
            

            

                
            

            

                
                                                        let v68 = C::u64_from_imm64(ctx, v67);

            

        

            

                4361
            

            

                
            

            

                
                                                        let v150 = C::ty_bits(ctx, v2.0);

            

        

            

                4362
            

            

                
            

            

                
                                                        let v151 = C::u8_as_u64(ctx, v150);

            

        

            

                4363
            

            

                
            

            

                
                                                        let v153 = C::u64_sub(ctx, v151, 0x1);

            

        

            

                4364
            

            

                
            

            

                
                                                        let v479 = C::u64_eq(ctx, v68, v153);

            

        

            

                4365
            

            

                
            

            

                
                                                        if v479 == true {

            

        

            

                4366
            

            

                
            

            

                
                                                            if v2.0 == v63.0 {

            

        

            

                4367
            

            

                
            

            

                
                                                                let v480 = constructor_sshr(

            

        

            

                4368
            

            

                
            

            

                
                                                                    ctx, v2.0, v59.0, v59.1,

            

        

            

                4369
            

            

                
            

            

                
                                                                );

            

        

            

                4370
            

            

                
            

            

                
                                                                // Rule at src/opts/shifts.isle line 102.

            

        

            

                4371
            

            

                
            

            

                
                                                                returns.push(v480);

            

        

            

                4372
            

            

                
            

            

                
                                                            }

            

        

            

                4373
            

            

                
            

            

                
                                                        }

            

        

            

                4374
            

            

                
            

            

                
                                                    }

            

        

            

                4375
            

            

                
            

            

                
                                                }

            

        

            

                4376
            

            

                
            

            

                
                                            }

            

        

            

                4377
            

            

                
            

            

                
                                        }

            

        

            

                4378
            

            

                
            

            

                
                                    }

            

        

            

                4379
            

            

                
            

            

                
                                }

            

        

            

                4380
            

            

                
            

            

                
                                &InstructionData::Unary {

            

        

            

                4381
            

            

                
            

            

                
                                    opcode: ref v33,

            

        

            

                4382
            

            

                
            

            

                
                                    arg: v34,

            

        

            

                4383
            

            

                
            

            

                
                                } => {

            

        

            

                4384
            

            

                
            

            

                
                                    match v33 {

            

        

            

                4385
            

            

                
            

            

                
                                        &Opcode::Splat => {

            

        

            

                4386
            

            

                
            

            

                
                                            if v2.0 == v30.0 {

            

        

            

                4387
            

            

                
            

            

                
                                                let v481 = C::lane_type(ctx, v2.0);

            

        

            

                4388
            

            

                
            

            

                
                                                let v506 = constructor_ineg(ctx, v481, v34);

            

        

            

                4389
            

            

                
            

            

                
                                                let v507 = constructor_splat(ctx, v2.0, v506);

            

        

            

                4390
            

            

                
            

            

                
                                                // Rule at src/opts/vector.isle line 45.

            

        

            

                4391
            

            

                
            

            

                
                                                returns.push(v507);

            

        

            

                4392
            

            

                
            

            

                
                                            }

            

        

            

                4393
            

            

                
            

            

                
                                        }

            

        

            

                4394
            

            

                
            

            

                
                                        &Opcode::Ineg => {

            

        

            

                4395
            

            

                
            

            

                
                                            if v2.0 == v30.0 {

            

        

            

                4396
            

            

                
            

            

                
                                                let v35 = C::subsume(ctx, v34);

            

        

            

                4397
            

            

                
            

            

                
                                                // Rule at src/opts/arithmetic.isle line 25.

            

        

            

                4398
            

            

                
            

            

                
                                                returns.push(v35);

            

        

            

                4399
            

            

                
            

            

                
                                            }

            

        

            

                4400
            

            

                
            

            

                
                                        }

            

        

            

                4401
            

            

                
            

            

                
                                        _ => {}

            

        

            

                4402
            

            

                
            

            

                
                                    }

            

        

            

                4403
            

            

                
            

            

                
                                }

            

        

            

                4404
            

            

                
            

            

                
                                _ => {}

            

        

            

                4405
            

            

                
            

            

                
                            }

            

        

            

                4406
            

            

                
            

            

                
                        }

            

        

            

                4407
            

            

                
            

            

                
                    }

            

        

            

                4408
            

            

                
            

            

                
                    &Opcode::Iabs => {

            

        

            

                4409
            

            

                
            

            

                
                        let v29 = C::inst_data_etor(ctx, v28);

            

        

            

                4410
            

            

                
            

            

                
                        let mut v29 = v29;

            

        

            

                4411
            

            

                
            

            

                
                        while let Some(v30) = v29.next(ctx) {

            

        

            

                4412
            

            

                
            

            

                
                            if let &InstructionData::Unary {

            

        

            

                4413
            

            

                
            

            

                
                                opcode: ref v33,

            

        

            

                4414
            

            

                
            

            

                
                                arg: v34,

            

        

            

                4415
            

            

                
            

            

                
                            } = &v30.1

            

        

            

                4416
            

            

                
            

            

                
                            {

            

        

            

                4417
            

            

                
            

            

                
                                match v33 {

            

        

            

                4418
            

            

                
            

            

                
                                    &Opcode::Splat => {

            

        

            

                4419
            

            

                
            

            

                
                                        if v2.0 == v30.0 {

            

        

            

                4420
            

            

                
            

            

                
                                            let v481 = C::lane_type(ctx, v2.0);

            

        

            

                4421
            

            

                
            

            

                
                                            let v508 = constructor_iabs(ctx, v481, v34);

            

        

            

                4422
            

            

                
            

            

                
                                            let v509 = constructor_splat(ctx, v2.0, v508);

            

        

            

                4423
            

            

                
            

            

                
                                            // Rule at src/opts/vector.isle line 48.

            

        

            

                4424
            

            

                
            

            

                
                                            returns.push(v509);

            

        

            

                4425
            

            

                
            

            

                
                                        }

            

        

            

                4426
            

            

                
            

            

                
                                    }

            

        

            

                4427
            

            

                
            

            

                
                                    &Opcode::Ineg => {

            

        

            

                4428
            

            

                
            

            

                
                                        if v2.0 == v30.0 {

            

        

            

                4429
            

            

                
            

            

                
                                            let v42 = constructor_iabs(ctx, v2.0, v34);

            

        

            

                4430
            

            

                
            

            

                
                                            // Rule at src/opts/arithmetic.isle line 32.

            

        

            

                4431
            

            

                
            

            

                
                                            returns.push(v42);

            

        

            

                4432
            

            

                
            

            

                
                                        }

            

        

            

                4433
            

            

                
            

            

                
                                    }

            

        

            

                4434
            

            

                
            

            

                
                                    &Opcode::Iabs => {

            

        

            

                4435
            

            

                
            

            

                
                                        if v2.0 == v30.0 {

            

        

            

                4436
            

            

                
            

            

                
                                            let v43 = C::subsume(ctx, v28);

            

        

            

                4437
            

            

                
            

            

                
                                            // Rule at src/opts/arithmetic.isle line 36.

            

        

            

                4438
            

            

                
            

            

                
                                            returns.push(v43);

            

        

            

                4439
            

            

                
            

            

                
                                        }

            

        

            

                4440
            

            

                
            

            

                
                                    }

            

        

            

                4441
            

            

                
            

            

                
                                    _ => {}

            

        

            

                4442
            

            

                
            

            

                
                                }

            

        

            

                4443
            

            

                
            

            

                
                            }

            

        

            

                4444
            

            

                
            

            

                
                        }

            

        

            

                4445
            

            

                
            

            

                
                    }

            

        

            

                4446
            

            

                
            

            

                
                    &Opcode::Bnot => {

            

        

            

                4447
            

            

                
            

            

                
                        let v29 = C::inst_data_etor(ctx, v28);

            

        

            

                4448
            

            

                
            

            

                
                        let mut v29 = v29;

            

        

            

                4449
            

            

                
            

            

                
                        while let Some(v30) = v29.next(ctx) {

            

        

            

                4450
            

            

                
            

            

                
                            match &v30.1 {

            

        

            

                4451
            

            

                
            

            

                
                                &InstructionData::Binary {

            

        

            

                4452
            

            

                
            

            

                
                                    opcode: ref v57,

            

        

            

                4453
            

            

                
            

            

                
                                    args: ref v58,

            

        

            

                4454
            

            

                
            

            

                
                                } => {

            

        

            

                4455
            

            

                
            

            

                
                                    match v57 {

            

        

            

                4456
            

            

                
            

            

                
                                        &Opcode::Iadd => {

            

        

            

                4457
            

            

                
            

            

                
                                            if v2.0 == v30.0 {

            

        

            

                4458
            

            

                
            

            

                
                                                let v59 = C::unpack_value_array_2(ctx, v58);

            

        

            

                4459
            

            

                
            

            

                
                                                let v62 = C::inst_data_etor(ctx, v59.1);

            

        

            

                4460
            

            

                
            

            

                
                                                let mut v62 = v62;

            

        

            

                4461
            

            

                
            

            

                
                                                while let Some(v63) = v62.next(ctx) {

            

        

            

                4462
            

            

                
            

            

                
                                                    if let &InstructionData::UnaryImm {

            

        

            

                4463
            

            

                
            

            

                
                                                        opcode: ref v66,

            

        

            

                4464
            

            

                
            

            

                
                                                        imm: v67,

            

        

            

                4465
            

            

                
            

            

                
                                                    } = &v63.1

            

        

            

                4466
            

            

                
            

            

                
                                                    {

            

        

            

                4467
            

            

                
            

            

                
                                                        if let &Opcode::Iconst = v66 {

            

        

            

                4468
            

            

                
            

            

                
                                                            let v70 = C::i64_sextend_imm64(

            

        

            

                4469
            

            

                
            

            

                
                                                                ctx, v2.0, v67,

            

        

            

                4470
            

            

                
            

            

                
                                                            );

            

        

            

                4471
            

            

                
            

            

                
                                                            if v70 == -0x1 {

            

        

            

                4472
            

            

                
            

            

                
                                                                if v2.0 == v63.0 {

            

        

            

                4473
            

            

                
            

            

                
                                                                    let v69 = constructor_ineg(

            

        

            

                4474
            

            

                
            

            

                
                                                                        ctx, v2.0, v59.0,

            

        

            

                4475
            

            

                
            

            

                
                                                                    );

            

        

            

                4476
            

            

                
            

            

                
                                                                    // Rule at src/opts/arithmetic.isle line 82.

            

        

            

                4477
            

            

                
            

            

                
                                                                    returns.push(v69);

            

        

            

                4478
            

            

                
            

            

                
                                                                }

            

        

            

                4479
            

            

                
            

            

                
                                                            }

            

        

            

                4480
            

            

                
            

            

                
                                                        }

            

        

            

                4481
            

            

                
            

            

                
                                                    }

            

        

            

                4482
            

            

                
            

            

                
                                                }

            

        

            

                4483
            

            

                
            

            

                
                                                let v71 = C::inst_data_etor(ctx, v59.0);

            

        

            

                4484
            

            

                
            

            

                
                                                let mut v71 = v71;

            

        

            

                4485
            

            

                
            

            

                
                                                while let Some(v72) = v71.next(ctx) {

            

        

            

                4486
            

            

                
            

            

                
                                                    if let &InstructionData::UnaryImm {

            

        

            

                4487
            

            

                
            

            

                
                                                        opcode: ref v75,

            

        

            

                4488
            

            

                
            

            

                
                                                        imm: v76,

            

        

            

                4489
            

            

                
            

            

                
                                                    } = &v72.1

            

        

            

                4490
            

            

                
            

            

                
                                                    {

            

        

            

                4491
            

            

                
            

            

                
                                                        if let &Opcode::Iconst = v75 {

            

        

            

                4492
            

            

                
            

            

                
                                                            let v77 = C::i64_sextend_imm64(

            

        

            

                4493
            

            

                
            

            

                
                                                                ctx, v2.0, v76,

            

        

            

                4494
            

            

                
            

            

                
                                                            );

            

        

            

                4495
            

            

                
            

            

                
                                                            if v77 == -0x1 {

            

        

            

                4496
            

            

                
            

            

                
                                                                if v2.0 == v72.0 {

            

        

            

                4497
            

            

                
            

            

                
                                                                    let v78 = constructor_ineg(

            

        

            

                4498
            

            

                
            

            

                
                                                                        ctx, v2.0, v59.1,

            

        

            

                4499
            

            

                
            

            

                
                                                                    );

            

        

            

                4500
            

            

                
            

            

                
                                                                    // Rule at src/opts/arithmetic.isle line 85.

            

        

            

                4501
            

            

                
            

            

                
                                                                    returns.push(v78);

            

        

            

                4502
            

            

                
            

            

                
                                                                }

            

        

            

                4503
            

            

                
            

            

                
                                                            }

            

        

            

                4504
            

            

                
            

            

                
                                                        }

            

        

            

                4505
            

            

                
            

            

                
                                                    }

            

        

            

                4506
            

            

                
            

            

                
                                                }

            

        

            

                4507
            

            

                
            

            

                
                                            }

            

        

            

                4508
            

            

                
            

            

                
                                        }

            

        

            

                4509
            

            

                
            

            

                
                                        &Opcode::Isub => {

            

        

            

                4510
            

            

                
            

            

                
                                            if v2.0 == v30.0 {

            

        

            

                4511
            

            

                
            

            

                
                                                let v59 = C::unpack_value_array_2(ctx, v58);

            

        

            

                4512
            

            

                
            

            

                
                                                let v62 = C::inst_data_etor(ctx, v59.1);

            

        

            

                4513
            

            

                
            

            

                
                                                let mut v62 = v62;

            

        

            

                4514
            

            

                
            

            

                
                                                while let Some(v63) = v62.next(ctx) {

            

        

            

                4515
            

            

                
            

            

                
                                                    if let &InstructionData::UnaryImm {

            

        

            

                4516
            

            

                
            

            

                
                                                        opcode: ref v66,

            

        

            

                4517
            

            

                
            

            

                
                                                        imm: v67,

            

        

            

                4518
            

            

                
            

            

                
                                                    } = &v63.1

            

        

            

                4519
            

            

                
            

            

                
                                                    {

            

        

            

                4520
            

            

                
            

            

                
                                                        if let &Opcode::Iconst = v66 {

            

        

            

                4521
            

            

                
            

            

                
                                                            let v68 = C::u64_from_imm64(ctx, v67);

            

        

            

                4522
            

            

                
            

            

                
                                                            if v68 == 0x1 {

            

        

            

                4523
            

            

                
            

            

                
                                                                if v2.0 == v63.0 {

            

        

            

                4524
            

            

                
            

            

                
                                                                    let v69 = constructor_ineg(

            

        

            

                4525
            

            

                
            

            

                
                                                                        ctx, v2.0, v59.0,

            

        

            

                4526
            

            

                
            

            

                
                                                                    );

            

        

            

                4527
            

            

                
            

            

                
                                                                    // Rule at src/opts/arithmetic.isle line 80.

            

        

            

                4528
            

            

                
            

            

                
                                                                    returns.push(v69);

            

        

            

                4529
            

            

                
            

            

                
                                                                }

            

        

            

                4530
            

            

                
            

            

                
                                                            }

            

        

            

                4531
            

            

                
            

            

                
                                                        }

            

        

            

                4532
            

            

                
            

            

                
                                                    }

            

        

            

                4533
            

            

                
            

            

                
                                                }

            

        

            

                4534
            

            

                
            

            

                
                                            }

            

        

            

                4535
            

            

                
            

            

                
                                        }

            

        

            

                4536
            

            

                
            

            

                
                                        &Opcode::Band => {

            

        

            

                4537
            

            

                
            

            

                
                                            let v59 = C::unpack_value_array_2(ctx, v58);

            

        

            

                4538
            

            

                
            

            

                
                                            let v119 = constructor_bnot(ctx, v2.0, v59.0);

            

        

            

                4539
            

            

                
            

            

                
                                            let v120 = constructor_bnot(ctx, v2.0, v59.1);

            

        

            

                4540
            

            

                
            

            

                
                                            let v122 = constructor_bor(ctx, v2.0, v119, v120);

            

        

            

                4541
            

            

                
            

            

                
                                            // Rule at src/opts/bitops.isle line 60.

            

        

            

                4542
            

            

                
            

            

                
                                            returns.push(v122);

            

        

            

                4543
            

            

                
            

            

                
                                        }

            

        

            

                4544
            

            

                
            

            

                
                                        &Opcode::Bor => {

            

        

            

                4545
            

            

                
            

            

                
                                            if v2.0 == v30.0 {

            

        

            

                4546
            

            

                
            

            

                
                                                let v59 = C::unpack_value_array_2(ctx, v58);

            

        

            

                4547
            

            

                
            

            

                
                                                let v119 = constructor_bnot(ctx, v2.0, v59.0);

            

        

            

                4548
            

            

                
            

            

                
                                                let v120 = constructor_bnot(ctx, v2.0, v59.1);

            

        

            

                4549
            

            

                
            

            

                
                                                let v121 = constructor_band(ctx, v2.0, v119, v120);

            

        

            

                4550
            

            

                
            

            

                
                                                // Rule at src/opts/bitops.isle line 57.

            

        

            

                4551
            

            

                
            

            

                
                                                returns.push(v121);

            

        

            

                4552
            

            

                
            

            

                
                                            }

            

        

            

                4553
            

            

                
            

            

                
                                        }

            

        

            

                4554
            

            

                
            

            

                
                                        _ => {}

            

        

            

                4555
            

            

                
            

            

                
                                    }

            

        

            

                4556
            

            

                
            

            

                
                                }

            

        

            

                4557
            

            

                
            

            

                
                                &InstructionData::Unary {

            

        

            

                4558
            

            

                
            

            

                
                                    opcode: ref v33,

            

        

            

                4559
            

            

                
            

            

                
                                    arg: v34,

            

        

            

                4560
            

            

                
            

            

                
                                } => {

            

        

            

                4561
            

            

                
            

            

                
                                    match v33 {

            

        

            

                4562
            

            

                
            

            

                
                                        &Opcode::Splat => {

            

        

            

                4563
            

            

                
            

            

                
                                            let v486 = C::ty_vector_not_float(ctx, v2.0);

            

        

            

                4564
            

            

                
            

            

                
                                            if let Some(v487) = v486 {

            

        

            

                4565
            

            

                
            

            

                
                                                if v2.0 == v30.0 {

            

        

            

                4566
            

            

                
            

            

                
                                                    let v481 = C::lane_type(ctx, v2.0);

            

        

            

                4567
            

            

                
            

            

                
                                                    let v494 = constructor_bnot(ctx, v481, v34);

            

        

            

                4568
            

            

                
            

            

                
                                                    let v495 = constructor_splat(ctx, v2.0, v494);

            

        

            

                4569
            

            

                
            

            

                
                                                    // Rule at src/opts/vector.isle line 26.

            

        

            

                4570
            

            

                
            

            

                
                                                    returns.push(v495);

            

        

            

                4571
            

            

                
            

            

                
                                                }

            

        

            

                4572
            

            

                
            

            

                
                                            }

            

        

            

                4573
            

            

                
            

            

                
                                        }

            

        

            

                4574
            

            

                
            

            

                
                                        &Opcode::Bnot => {

            

        

            

                4575
            

            

                
            

            

                
                                            if v2.0 == v30.0 {

            

        

            

                4576
            

            

                
            

            

                
                                                let v35 = C::subsume(ctx, v34);

            

        

            

                4577
            

            

                
            

            

                
                                                // Rule at src/opts/bitops.isle line 53.

            

        

            

                4578
            

            

                
            

            

                
                                                returns.push(v35);

            

        

            

                4579
            

            

                
            

            

                
                                            }

            

        

            

                4580
            

            

                
            

            

                
                                        }

            

        

            

                4581
            

            

                
            

            

                
                                        _ => {}

            

        

            

                4582
            

            

                
            

            

                
                                    }

            

        

            

                4583
            

            

                
            

            

                
                                }

            

        

            

                4584
            

            

                
            

            

                
                                &InstructionData::UnaryImm {

            

        

            

                4585
            

            

                
            

            

                
                                    opcode: ref v222,

            

        

            

                4586
            

            

                
            

            

                
                                    imm: v223,

            

        

            

                4587
            

            

                
            

            

                
                                } => {

            

        

            

                4588
            

            

                
            

            

                
                                    if let &Opcode::Iconst = v222 {

            

        

            

                4589
            

            

                
            

            

                
                                        let v44 = C::fits_in_64(ctx, v2.0);

            

        

            

                4590
            

            

                
            

            

                
                                        if let Some(v45) = v44 {

            

        

            

                4591
            

            

                
            

            

                
                                            if v30.0 == v45 {

            

        

            

                4592
            

            

                
            

            

                
                                                let v224 = C::u64_from_imm64(ctx, v223);

            

        

            

                4593
            

            

                
            

            

                
                                                let v225 = C::u64_not(ctx, v224);

            

        

            

                4594
            

            

                
            

            

                
                                                let v226 = C::imm64_masked(ctx, v45, v225);

            

        

            

                4595
            

            

                
            

            

                
                                                let v227 = constructor_iconst(ctx, v45, v226);

            

        

            

                4596
            

            

                
            

            

                
                                                let v228 = C::subsume(ctx, v227);

            

        

            

                4597
            

            

                
            

            

                
                                                // Rule at src/opts/cprop.isle line 53.

            

        

            

                4598
            

            

                
            

            

                
                                                returns.push(v228);

            

        

            

                4599
            

            

                
            

            

                
                                            }

            

        

            

                4600
            

            

                
            

            

                
                                        }

            

        

            

                4601
            

            

                
            

            

                
                                    }

            

        

            

                4602
            

            

                
            

            

                
                                }

            

        

            

                4603
            

            

                
            

            

                
                                _ => {}

            

        

            

                4604
            

            

                
            

            

                
                            }

            

        

            

                4605
            

            

                
            

            

                
                        }

            

        

            

                4606
            

            

                
            

            

                
                        let v413 = C::remat(ctx, arg0);

            

        

            

                4607
            

            

                
            

            

                
                        // Rule at src/opts/remat.isle line 24.

            

        

            

                4608
            

            

                
            

            

                
                        returns.push(v413);

            

        

            

                4609
            

            

                
            

            

                
                    }

            

        

            

                4610
            

            

                
            

            

                
                    &Opcode::Bitrev => {

            

        

            

                4611
            

            

                
            

            

                
                        let v29 = C::inst_data_etor(ctx, v28);

            

        

            

                4612
            

            

                
            

            

                
                        let mut v29 = v29;

            

        

            

                4613
            

            

                
            

            

                
                        while let Some(v30) = v29.next(ctx) {

            

        

            

                4614
            

            

                
            

            

                
                            if let &InstructionData::Unary {

            

        

            

                4615
            

            

                
            

            

                
                                opcode: ref v33,

            

        

            

                4616
            

            

                
            

            

                
                                arg: v34,

            

        

            

                4617
            

            

                
            

            

                
                            } = &v30.1

            

        

            

                4618
            

            

                
            

            

                
                            {

            

        

            

                4619
            

            

                
            

            

                
                                if let &Opcode::Bitrev = v33 {

            

        

            

                4620
            

            

                
            

            

                
                                    if v2.0 == v30.0 {

            

        

            

                4621
            

            

                
            

            

                
                                        let v35 = C::subsume(ctx, v34);

            

        

            

                4622
            

            

                
            

            

                
                                        // Rule at src/opts/bitops.isle line 147.

            

        

            

                4623
            

            

                
            

            

                
                                        returns.push(v35);

            

        

            

                4624
            

            

                
            

            

                
                                    }

            

        

            

                4625
            

            

                
            

            

                
                                }

            

        

            

                4626
            

            

                
            

            

                
                            }

            

        

            

                4627
            

            

                
            

            

                
                        }

            

        

            

                4628
            

            

                
            

            

                
                    }

            

        

            

                4629
            

            

                
            

            

                
                    &Opcode::Bswap => {

            

        

            

                4630
            

            

                
            

            

                
                        let v29 = C::inst_data_etor(ctx, v28);

            

        

            

                4631
            

            

                
            

            

                
                        let mut v29 = v29;

            

        

            

                4632
            

            

                
            

            

                
                        while let Some(v30) = v29.next(ctx) {

            

        

            

                4633
            

            

                
            

            

                
                            if let &InstructionData::Unary {

            

        

            

                4634
            

            

                
            

            

                
                                opcode: ref v33,

            

        

            

                4635
            

            

                
            

            

                
                                arg: v34,

            

        

            

                4636
            

            

                
            

            

                
                            } = &v30.1

            

        

            

                4637
            

            

                
            

            

                
                            {

            

        

            

                4638
            

            

                
            

            

                
                                if let &Opcode::Bswap = v33 {

            

        

            

                4639
            

            

                
            

            

                
                                    if v2.0 == v30.0 {

            

        

            

                4640
            

            

                
            

            

                
                                        let v35 = C::subsume(ctx, v34);

            

        

            

                4641
            

            

                
            

            

                
                                        // Rule at src/opts/bitops.isle line 144.

            

        

            

                4642
            

            

                
            

            

                
                                        returns.push(v35);

            

        

            

                4643
            

            

                
            

            

                
                                    }

            

        

            

                4644
            

            

                
            

            

                
                                }

            

        

            

                4645
            

            

                
            

            

                
                            }

            

        

            

                4646
            

            

                
            

            

                
                        }

            

        

            

                4647
            

            

                
            

            

                
                    }

            

        

            

                4648
            

            

                
            

            

                
                    &Opcode::Popcnt => {

            

        

            

                4649
            

            

                
            

            

                
                        let v29 = C::inst_data_etor(ctx, v28);

            

        

            

                4650
            

            

                
            

            

                
                        let mut v29 = v29;

            

        

            

                4651
            

            

                
            

            

                
                        while let Some(v30) = v29.next(ctx) {

            

        

            

                4652
            

            

                
            

            

                
                            if let &InstructionData::Unary {

            

        

            

                4653
            

            

                
            

            

                
                                opcode: ref v33,

            

        

            

                4654
            

            

                
            

            

                
                                arg: v34,

            

        

            

                4655
            

            

                
            

            

                
                            } = &v30.1

            

        

            

                4656
            

            

                
            

            

                
                            {

            

        

            

                4657
            

            

                
            

            

                
                                if let &Opcode::Splat = v33 {

            

        

            

                4658
            

            

                
            

            

                
                                    if v2.0 == v30.0 {

            

        

            

                4659
            

            

                
            

            

                
                                        let v481 = C::lane_type(ctx, v2.0);

            

        

            

                4660
            

            

                
            

            

                
                                        let v510 = constructor_popcnt(ctx, v481, v34);

            

        

            

                4661
            

            

                
            

            

                
                                        let v511 = constructor_splat(ctx, v2.0, v510);

            

        

            

                4662
            

            

                
            

            

                
                                        // Rule at src/opts/vector.isle line 51.

            

        

            

                4663
            

            

                
            

            

                
                                        returns.push(v511);

            

        

            

                4664
            

            

                
            

            

                
                                    }

            

        

            

                4665
            

            

                
            

            

                
                                }

            

        

            

                4666
            

            

                
            

            

                
                            }

            

        

            

                4667
            

            

                
            

            

                
                        }

            

        

            

                4668
            

            

                
            

            

                
                    }

            

        

            

                4669
            

            

                
            

            

                
                    &Opcode::Fneg => {

            

        

            

                4670
            

            

                
            

            

                
                        let v29 = C::inst_data_etor(ctx, v28);

            

        

            

                4671
            

            

                
            

            

                
                        let mut v29 = v29;

            

        

            

                4672
            

            

                
            

            

                
                        while let Some(v30) = v29.next(ctx) {

            

        

            

                4673
            

            

                
            

            

                
                            if let &InstructionData::Unary {

            

        

            

                4674
            

            

                
            

            

                
                                opcode: ref v33,

            

        

            

                4675
            

            

                
            

            

                
                                arg: v34,

            

        

            

                4676
            

            

                
            

            

                
                            } = &v30.1

            

        

            

                4677
            

            

                
            

            

                
                            {

            

        

            

                4678
            

            

                
            

            

                
                                if let &Opcode::Fneg = v33 {

            

        

            

                4679
            

            

                
            

            

                
                                    if v2.0 == v30.0 {

            

        

            

                4680
            

            

                
            

            

                
                                        let v35 = C::subsume(ctx, v34);

            

        

            

                4681
            

            

                
            

            

                
                                        // Rule at src/opts/arithmetic.isle line 118.

            

        

            

                4682
            

            

                
            

            

                
                                        returns.push(v35);

            

        

            

                4683
            

            

                
            

            

                
                                    }

            

        

            

                4684
            

            

                
            

            

                
                                }

            

        

            

                4685
            

            

                
            

            

                
                            }

            

        

            

                4686
            

            

                
            

            

                
                        }

            

        

            

                4687
            

            

                
            

            

                
                    }

            

        

            

                4688
            

            

                
            

            

                
                    &Opcode::Bmask => {

            

        

            

                4689
            

            

                
            

            

                
                        let v163 = constructor_truthy(ctx, v28);

            

        

            

                4690
            

            

                
            

            

                
                        let mut v163 = v163;

            

        

            

                4691
            

            

                
            

            

                
                        while let Some(v164) = v163.next(ctx) {

            

        

            

                4692
            

            

                
            

            

                
                            let v165 = constructor_bmask(ctx, v2.0, v164);

            

        

            

                4693
            

            

                
            

            

                
                            // Rule at src/opts/bitops.isle line 127.

            

        

            

                4694
            

            

                
            

            

                
                            returns.push(v165);

            

        

            

                4695
            

            

                
            

            

                
                        }

            

        

            

                4696
            

            

                
            

            

                
                    }

            

        

            

                4697
            

            

                
            

            

                
                    &Opcode::Ireduce => {

            

        

            

                4698
            

            

                
            

            

                
                        let v29 = C::inst_data_etor(ctx, v28);

            

        

            

                4699
            

            

                
            

            

                
                        let mut v29 = v29;

            

        

            

                4700
            

            

                
            

            

                
                        while let Some(v30) = v29.next(ctx) {

            

        

            

                4701
            

            

                
            

            

                
                            match &v30.1 {

            

        

            

                4702
            

            

                
            

            

                
                                &InstructionData::Unary {

            

        

            

                4703
            

            

                
            

            

                
                                    opcode: ref v33,

            

        

            

                4704
            

            

                
            

            

                
                                    arg: v34,

            

        

            

                4705
            

            

                
            

            

                
                                } => {

            

        

            

                4706
            

            

                
            

            

                
                                    match v33 {

            

        

            

                4707
            

            

                
            

            

                
                                        &Opcode::Bmask => {

            

        

            

                4708
            

            

                
            

            

                
                                            let v187 = constructor_bmask(ctx, v2.0, v34);

            

        

            

                4709
            

            

                
            

            

                
                                            // Rule at src/opts/bitops.isle line 141.

            

        

            

                4710
            

            

                
            

            

                
                                            returns.push(v187);

            

        

            

                4711
            

            

                
            

            

                
                                        }

            

        

            

                4712
            

            

                
            

            

                
                                        &Opcode::Uextend => {

            

        

            

                4713
            

            

                
            

            

                
                                            let v345 = C::value_type(ctx, v34);

            

        

            

                4714
            

            

                
            

            

                
                                            if v2.0 == v345 {

            

        

            

                4715
            

            

                
            

            

                
                                                // Rule at src/opts/extends.isle line 34.

            

        

            

                4716
            

            

                
            

            

                
                                                returns.push(v34);

            

        

            

                4717
            

            

                
            

            

                
                                            }

            

        

            

                4718
            

            

                
            

            

                
                                        }

            

        

            

                4719
            

            

                
            

            

                
                                        &Opcode::Sextend => {

            

        

            

                4720
            

            

                
            

            

                
                                            let v345 = C::value_type(ctx, v34);

            

        

            

                4721
            

            

                
            

            

                
                                            if v2.0 == v345 {

            

        

            

                4722
            

            

                
            

            

                
                                                // Rule at src/opts/extends.isle line 33.

            

        

            

                4723
            

            

                
            

            

                
                                                returns.push(v34);

            

        

            

                4724
            

            

                
            

            

                
                                            }

            

        

            

                4725
            

            

                
            

            

                
                                        }

            

        

            

                4726
            

            

                
            

            

                
                                        _ => {}

            

        

            

                4727
            

            

                
            

            

                
                                    }

            

        

            

                4728
            

            

                
            

            

                
                                }

            

        

            

                4729
            

            

                
            

            

                
                                &InstructionData::UnaryImm {

            

        

            

                4730
            

            

                
            

            

                
                                    opcode: ref v222,

            

        

            

                4731
            

            

                
            

            

                
                                    imm: v223,

            

        

            

                4732
            

            

                
            

            

                
                                } => {

            

        

            

                4733
            

            

                
            

            

                
                                    if let &Opcode::Iconst = v222 {

            

        

            

                4734
            

            

                
            

            

                
                                        let v238 = C::fits_in_64(ctx, v30.0);

            

        

            

                4735
            

            

                
            

            

                
                                        if let Some(v239) = v238 {

            

        

            

                4736
            

            

                
            

            

                
                                            let v224 = C::u64_from_imm64(ctx, v223);

            

        

            

                4737
            

            

                
            

            

                
                                            let v240 = C::imm64_masked(ctx, v2.0, v224);

            

        

            

                4738
            

            

                
            

            

                
                                            let v241 = constructor_iconst(ctx, v2.0, v240);

            

        

            

                4739
            

            

                
            

            

                
                                            let v242 = C::subsume(ctx, v241);

            

        

            

                4740
            

            

                
            

            

                
                                            // Rule at src/opts/cprop.isle line 73.

            

        

            

                4741
            

            

                
            

            

                
                                            returns.push(v242);

            

        

            

                4742
            

            

                
            

            

                
                                        }

            

        

            

                4743
            

            

                
            

            

                
                                    }

            

        

            

                4744
            

            

                
            

            

                
                                }

            

        

            

                4745
            

            

                
            

            

                
                                _ => {}

            

        

            

                4746
            

            

                
            

            

                
                            }

            

        

            

                4747
            

            

                
            

            

                
                        }

            

        

            

                4748
            

            

                
            

            

                
                    }

            

        

            

                4749
            

            

                
            

            

                
                    &Opcode::SwidenLow => {

            

        

            

                4750
            

            

                
            

            

                
                        let v29 = C::inst_data_etor(ctx, v28);

            

        

            

                4751
            

            

                
            

            

                
                        let mut v29 = v29;

            

        

            

                4752
            

            

                
            

            

                
                        while let Some(v30) = v29.next(ctx) {

            

        

            

                4753
            

            

                
            

            

                
                            if let &InstructionData::Unary {

            

        

            

                4754
            

            

                
            

            

                
                                opcode: ref v33,

            

        

            

                4755
            

            

                
            

            

                
                                arg: v34,

            

        

            

                4756
            

            

                
            

            

                
                            } = &v30.1

            

        

            

                4757
            

            

                
            

            

                
                            {

            

        

            

                4758
            

            

                
            

            

                
                                if let &Opcode::Splat = v33 {

            

        

            

                4759
            

            

                
            

            

                
                                    let v481 = C::lane_type(ctx, v2.0);

            

        

            

                4760
            

            

                
            

            

                
                                    let v530 = constructor_sextend(ctx, v481, v34);

            

        

            

                4761
            

            

                
            

            

                
                                    let v531 = constructor_splat(ctx, v2.0, v530);

            

        

            

                4762
            

            

                
            

            

                
                                    // Rule at src/opts/vector.isle line 85.

            

        

            

                4763
            

            

                
            

            

                
                                    returns.push(v531);

            

        

            

                4764
            

            

                
            

            

                
                                }

            

        

            

                4765
            

            

                
            

            

                
                            }

            

        

            

                4766
            

            

                
            

            

                
                        }

            

        

            

                4767
            

            

                
            

            

                
                    }

            

        

            

                4768
            

            

                
            

            

                
                    &Opcode::SwidenHigh => {

            

        

            

                4769
            

            

                
            

            

                
                        let v29 = C::inst_data_etor(ctx, v28);

            

        

            

                4770
            

            

                
            

            

                
                        let mut v29 = v29;

            

        

            

                4771
            

            

                
            

            

                
                        while let Some(v30) = v29.next(ctx) {

            

        

            

                4772
            

            

                
            

            

                
                            if let &InstructionData::Unary {

            

        

            

                4773
            

            

                
            

            

                
                                opcode: ref v33,

            

        

            

                4774
            

            

                
            

            

                
                                arg: v34,

            

        

            

                4775
            

            

                
            

            

                
                            } = &v30.1

            

        

            

                4776
            

            

                
            

            

                
                            {

            

        

            

                4777
            

            

                
            

            

                
                                if let &Opcode::Splat = v33 {

            

        

            

                4778
            

            

                
            

            

                
                                    let v481 = C::lane_type(ctx, v2.0);

            

        

            

                4779
            

            

                
            

            

                
                                    let v530 = constructor_sextend(ctx, v481, v34);

            

        

            

                4780
            

            

                
            

            

                
                                    let v531 = constructor_splat(ctx, v2.0, v530);

            

        

            

                4781
            

            

                
            

            

                
                                    // Rule at src/opts/vector.isle line 84.

            

        

            

                4782
            

            

                
            

            

                
                                    returns.push(v531);

            

        

            

                4783
            

            

                
            

            

                
                                }

            

        

            

                4784
            

            

                
            

            

                
                            }

            

        

            

                4785
            

            

                
            

            

                
                        }

            

        

            

                4786
            

            

                
            

            

                
                    }

            

        

            

                4787
            

            

                
            

            

                
                    &Opcode::UwidenLow => {

            

        

            

                4788
            

            

                
            

            

                
                        let v29 = C::inst_data_etor(ctx, v28);

            

        

            

                4789
            

            

                
            

            

                
                        let mut v29 = v29;

            

        

            

                4790
            

            

                
            

            

                
                        while let Some(v30) = v29.next(ctx) {

            

        

            

                4791
            

            

                
            

            

                
                            if let &InstructionData::Unary {

            

        

            

                4792
            

            

                
            

            

                
                                opcode: ref v33,

            

        

            

                4793
            

            

                
            

            

                
                                arg: v34,

            

        

            

                4794
            

            

                
            

            

                
                            } = &v30.1

            

        

            

                4795
            

            

                
            

            

                
                            {

            

        

            

                4796
            

            

                
            

            

                
                                if let &Opcode::Splat = v33 {

            

        

            

                4797
            

            

                
            

            

                
                                    let v481 = C::lane_type(ctx, v2.0);

            

        

            

                4798
            

            

                
            

            

                
                                    let v532 = constructor_uextend(ctx, v481, v34);

            

        

            

                4799
            

            

                
            

            

                
                                    let v533 = constructor_splat(ctx, v2.0, v532);

            

        

            

                4800
            

            

                
            

            

                
                                    // Rule at src/opts/vector.isle line 88.

            

        

            

                4801
            

            

                
            

            

                
                                    returns.push(v533);

            

        

            

                4802
            

            

                
            

            

                
                                }

            

        

            

                4803
            

            

                
            

            

                
                            }

            

        

            

                4804
            

            

                
            

            

                
                        }

            

        

            

                4805
            

            

                
            

            

                
                    }

            

        

            

                4806
            

            

                
            

            

                
                    &Opcode::UwidenHigh => {

            

        

            

                4807
            

            

                
            

            

                
                        let v29 = C::inst_data_etor(ctx, v28);

            

        

            

                4808
            

            

                
            

            

                
                        let mut v29 = v29;

            

        

            

                4809
            

            

                
            

            

                
                        while let Some(v30) = v29.next(ctx) {

            

        

            

                4810
            

            

                
            

            

                
                            if let &InstructionData::Unary {

            

        

            

                4811
            

            

                
            

            

                
                                opcode: ref v33,

            

        

            

                4812
            

            

                
            

            

                
                                arg: v34,

            

        

            

                4813
            

            

                
            

            

                
                            } = &v30.1

            

        

            

                4814
            

            

                
            

            

                
                            {

            

        

            

                4815
            

            

                
            

            

                
                                if let &Opcode::Splat = v33 {

            

        

            

                4816
            

            

                
            

            

                
                                    let v481 = C::lane_type(ctx, v2.0);

            

        

            

                4817
            

            

                
            

            

                
                                    let v532 = constructor_uextend(ctx, v481, v34);

            

        

            

                4818
            

            

                
            

            

                
                                    let v533 = constructor_splat(ctx, v2.0, v532);

            

        

            

                4819
            

            

                
            

            

                
                                    // Rule at src/opts/vector.isle line 87.

            

        

            

                4820
            

            

                
            

            

                
                                    returns.push(v533);

            

        

            

                4821
            

            

                
            

            

                
                                }

            

        

            

                4822
            

            

                
            

            

                
                            }

            

        

            

                4823
            

            

                
            

            

                
                        }

            

        

            

                4824
            

            

                
            

            

                
                    }

            

        

            

                4825
            

            

                
            

            

                
                    &Opcode::Uextend => {

            

        

            

                4826
            

            

                
            

            

                
                        let v29 = C::inst_data_etor(ctx, v28);

            

        

            

                4827
            

            

                
            

            

                
                        let mut v29 = v29;

            

        

            

                4828
            

            

                
            

            

                
                        while let Some(v30) = v29.next(ctx) {

            

        

            

                4829
            

            

                
            

            

                
                            match &v30.1 {

            

        

            

                4830
            

            

                
            

            

                
                                &InstructionData::Unary {

            

        

            

                4831
            

            

                
            

            

                
                                    opcode: ref v33,

            

        

            

                4832
            

            

                
            

            

                
                                    arg: v34,

            

        

            

                4833
            

            

                
            

            

                
                                } => {

            

        

            

                4834
            

            

                
            

            

                
                                    if let &Opcode::Uextend = v33 {

            

        

            

                4835
            

            

                
            

            

                
                                        let v331 = constructor_uextend(ctx, v2.0, v34);

            

        

            

                4836
            

            

                
            

            

                
                                        // Rule at src/opts/extends.isle line 2.

            

        

            

                4837
            

            

                
            

            

                
                                        returns.push(v331);

            

        

            

                4838
            

            

                
            

            

                
                                    }

            

        

            

                4839
            

            

                
            

            

                
                                }

            

        

            

                4840
            

            

                
            

            

                
                                &InstructionData::UnaryImm {

            

        

            

                4841
            

            

                
            

            

                
                                    opcode: ref v222,

            

        

            

                4842
            

            

                
            

            

                
                                    imm: v223,

            

        

            

                4843
            

            

                
            

            

                
                                } => {

            

        

            

                4844
            

            

                
            

            

                
                                    if let &Opcode::Iconst = v222 {

            

        

            

                4845
            

            

                
            

            

                
                                        let v44 = C::fits_in_64(ctx, v2.0);

            

        

            

                4846
            

            

                
            

            

                
                                        if let Some(v45) = v44 {

            

        

            

                4847
            

            

                
            

            

                
                                            let v243 = C::u64_uextend_imm64(ctx, v30.0, v223);

            

        

            

                4848
            

            

                
            

            

                
                                            let v244 = C::imm64(ctx, v243);

            

        

            

                4849
            

            

                
            

            

                
                                            let v245 = constructor_iconst(ctx, v45, v244);

            

        

            

                4850
            

            

                
            

            

                
                                            let v246 = C::subsume(ctx, v245);

            

        

            

                4851
            

            

                
            

            

                
                                            // Rule at src/opts/cprop.isle line 76.

            

        

            

                4852
            

            

                
            

            

                
                                            returns.push(v246);

            

        

            

                4853
            

            

                
            

            

                
                                        }

            

        

            

                4854
            

            

                
            

            

                
                                    }

            

        

            

                4855
            

            

                
            

            

                
                                }

            

        

            

                4856
            

            

                
            

            

                
                                _ => {}

            

        

            

                4857
            

            

                
            

            

                
                            }

            

        

            

                4858
            

            

                
            

            

                
                        }

            

        

            

                4859
            

            

                
            

            

                
                    }

            

        

            

                4860
            

            

                
            

            

                
                    &Opcode::Sextend => {

            

        

            

                4861
            

            

                
            

            

                
                        let v29 = C::inst_data_etor(ctx, v28);

            

        

            

                4862
            

            

                
            

            

                
                        let mut v29 = v29;

            

        

            

                4863
            

            

                
            

            

                
                        while let Some(v30) = v29.next(ctx) {

            

        

            

                4864
            

            

                
            

            

                
                            match &v30.1 {

            

        

            

                4865
            

            

                
            

            

                
                                &InstructionData::Unary {

            

        

            

                4866
            

            

                
            

            

                
                                    opcode: ref v33,

            

        

            

                4867
            

            

                
            

            

                
                                    arg: v34,

            

        

            

                4868
            

            

                
            

            

                
                                } => {

            

        

            

                4869
            

            

                
            

            

                
                                    match v33 {

            

        

            

                4870
            

            

                
            

            

                
                                        &Opcode::Bmask => {

            

        

            

                4871
            

            

                
            

            

                
                                            let v187 = constructor_bmask(ctx, v2.0, v34);

            

        

            

                4872
            

            

                
            

            

                
                                            // Rule at src/opts/bitops.isle line 140.

            

        

            

                4873
            

            

                
            

            

                
                                            returns.push(v187);

            

        

            

                4874
            

            

                
            

            

                
                                        }

            

        

            

                4875
            

            

                
            

            

                
                                        &Opcode::Sextend => {

            

        

            

                4876
            

            

                
            

            

                
                                            let v332 = constructor_sextend(ctx, v2.0, v34);

            

        

            

                4877
            

            

                
            

            

                
                                            // Rule at src/opts/extends.isle line 4.

            

        

            

                4878
            

            

                
            

            

                
                                            returns.push(v332);

            

        

            

                4879
            

            

                
            

            

                
                                        }

            

        

            

                4880
            

            

                
            

            

                
                                        _ => {}

            

        

            

                4881
            

            

                
            

            

                
                                    }

            

        

            

                4882
            

            

                
            

            

                
                                }

            

        

            

                4883
            

            

                
            

            

                
                                &InstructionData::UnaryImm {

            

        

            

                4884
            

            

                
            

            

                
                                    opcode: ref v222,

            

        

            

                4885
            

            

                
            

            

                
                                    imm: v223,

            

        

            

                4886
            

            

                
            

            

                
                                } => {

            

        

            

                4887
            

            

                
            

            

                
                                    if let &Opcode::Iconst = v222 {

            

        

            

                4888
            

            

                
            

            

                
                                        let v44 = C::fits_in_64(ctx, v2.0);

            

        

            

                4889
            

            

                
            

            

                
                                        if let Some(v45) = v44 {

            

        

            

                4890
            

            

                
            

            

                
                                            let v247 = C::i64_sextend_imm64(ctx, v30.0, v223);

            

        

            

                4891
            

            

                
            

            

                
                                            let v248 = C::i64_as_u64(ctx, v247);

            

        

            

                4892
            

            

                
            

            

                
                                            let v249 = C::imm64_masked(ctx, v45, v248);

            

        

            

                4893
            

            

                
            

            

                
                                            let v250 = constructor_iconst(ctx, v45, v249);

            

        

            

                4894
            

            

                
            

            

                
                                            let v251 = C::subsume(ctx, v250);

            

        

            

                4895
            

            

                
            

            

                
                                            // Rule at src/opts/cprop.isle line 79.

            

        

            

                4896
            

            

                
            

            

                
                                            returns.push(v251);

            

        

            

                4897
            

            

                
            

            

                
                                        }

            

        

            

                4898
            

            

                
            

            

                
                                    }

            

        

            

                4899
            

            

                
            

            

                
                                }

            

        

            

                4900
            

            

                
            

            

                
                                _ => {}

            

        

            

                4901
            

            

                
            

            

                
                            }

            

        

            

                4902
            

            

                
            

            

                
                        }

            

        

            

                4903
            

            

                
            

            

                
                    }

            

        

            

                4904
            

            

                
            

            

                
                    &Opcode::FcvtFromUint => {

            

        

            

                4905
            

            

                
            

            

                
                        let v29 = C::inst_data_etor(ctx, v28);

            

        

            

                4906
            

            

                
            

            

                
                        let mut v29 = v29;

            

        

            

                4907
            

            

                
            

            

                
                        while let Some(v30) = v29.next(ctx) {

            

        

            

                4908
            

            

                
            

            

                
                            if let &InstructionData::Unary {

            

        

            

                4909
            

            

                
            

            

                
                                opcode: ref v33,

            

        

            

                4910
            

            

                
            

            

                
                                arg: v34,

            

        

            

                4911
            

            

                
            

            

                
                            } = &v30.1

            

        

            

                4912
            

            

                
            

            

                
                            {

            

        

            

                4913
            

            

                
            

            

                
                                if let &Opcode::Splat = v33 {

            

        

            

                4914
            

            

                
            

            

                
                                    let v481 = C::lane_type(ctx, v2.0);

            

        

            

                4915
            

            

                
            

            

                
                                    let v482 = constructor_fcvt_from_uint(ctx, v481, v34);

            

        

            

                4916
            

            

                
            

            

                
                                    let v483 = constructor_splat(ctx, v2.0, v482);

            

        

            

                4917
            

            

                
            

            

                
                                    // Rule at src/opts/vector.isle line 6.

            

        

            

                4918
            

            

                
            

            

                
                                    returns.push(v483);

            

        

            

                4919
            

            

                
            

            

                
                                }

            

        

            

                4920
            

            

                
            

            

                
                            }

            

        

            

                4921
            

            

                
            

            

                
                        }

            

        

            

                4922
            

            

                
            

            

                
                    }

            

        

            

                4923
            

            

                
            

            

                
                    &Opcode::FcvtFromSint => {

            

        

            

                4924
            

            

                
            

            

                
                        let v29 = C::inst_data_etor(ctx, v28);

            

        

            

                4925
            

            

                
            

            

                
                        let mut v29 = v29;

            

        

            

                4926
            

            

                
            

            

                
                        while let Some(v30) = v29.next(ctx) {

            

        

            

                4927
            

            

                
            

            

                
                            if let &InstructionData::Unary {

            

        

            

                4928
            

            

                
            

            

                
                                opcode: ref v33,

            

        

            

                4929
            

            

                
            

            

                
                                arg: v34,

            

        

            

                4930
            

            

                
            

            

                
                            } = &v30.1

            

        

            

                4931
            

            

                
            

            

                
                            {

            

        

            

                4932
            

            

                
            

            

                
                                if let &Opcode::Splat = v33 {

            

        

            

                4933
            

            

                
            

            

                
                                    let v481 = C::lane_type(ctx, v2.0);

            

        

            

                4934
            

            

                
            

            

                
                                    let v484 = constructor_fcvt_from_sint(ctx, v481, v34);

            

        

            

                4935
            

            

                
            

            

                
                                    let v485 = constructor_splat(ctx, v2.0, v484);

            

        

            

                4936
            

            

                
            

            

                
                                    // Rule at src/opts/vector.isle line 8.

            

        

            

                4937
            

            

                
            

            

                
                                    returns.push(v485);

            

        

            

                4938
            

            

                
            

            

                
                                }

            

        

            

                4939
            

            

                
            

            

                
                            }

            

        

            

                4940
            

            

                
            

            

                
                        }

            

        

            

                4941
            

            

                
            

            

                
                    }

            

        

            

                4942
            

            

                
            

            

                
                    _ => {}

            

        

            

                4943
            

            

                
            

            

                
                }

            

        

            

                4944
            

            

                
            

            

                
            }

            

        

            

                4945
            

            

                
            

            

                
            &InstructionData::UnaryIeee32 {

            

        

            

                4946
            

            

                
            

            

                
                opcode: ref v416,

            

        

            

                4947
            

            

                
            

            

                
                imm: v417,

            

        

            

                4948
            

            

                
            

            

                
            } => {

            

        

            

                4949
            

            

                
            

            

                
                if let &Opcode::F32const = v416 {

            

        

            

                4950
            

            

                
            

            

                
                    let v413 = C::remat(ctx, arg0);

            

        

            

                4951
            

            

                
            

            

                
                    // Rule at src/opts/remat.isle line 28.

            

        

            

                4952
            

            

                
            

            

                
                    returns.push(v413);

            

        

            

                4953
            

            

                
            

            

                
                }

            

        

            

                4954
            

            

                
            

            

                
            }

            

        

            

                4955
            

            

                
            

            

                
            &InstructionData::UnaryIeee64 {

            

        

            

                4956
            

            

                
            

            

                
                opcode: ref v418,

            

        

            

                4957
            

            

                
            

            

                
                imm: v419,

            

        

            

                4958
            

            

                
            

            

                
            } => {

            

        

            

                4959
            

            

                
            

            

                
                if let &Opcode::F64const = v418 {

            

        

            

                4960
            

            

                
            

            

                
                    let v413 = C::remat(ctx, arg0);

            

        

            

                4961
            

            

                
            

            

                
                    // Rule at src/opts/remat.isle line 30.

            

        

            

                4962
            

            

                
            

            

                
                    returns.push(v413);

            

        

            

                4963
            

            

                
            

            

                
                }

            

        

            

                4964
            

            

                
            

            

                
            }

            

        

            

                4965
            

            

                
            

            

                
            &InstructionData::UnaryImm {

            

        

            

                4966
            

            

                
            

            

                
                opcode: ref v414,

            

        

            

                4967
            

            

                
            

            

                
                imm: v415,

            

        

            

                4968
            

            

                
            

            

                
            } => {

            

        

            

                4969
            

            

                
            

            

                
                if let &Opcode::Iconst = v414 {

            

        

            

                4970
            

            

                
            

            

                
                    let v413 = C::remat(ctx, arg0);

            

        

            

                4971
            

            

                
            

            

                
                    // Rule at src/opts/remat.isle line 26.

            

        

            

                4972
            

            

                
            

            

                
                    returns.push(v413);

            

        

            

                4973
            

            

                
            

            

                
                }

            

        

            

                4974
            

            

                
            

            

                
            }

            

        

            

                4975
            

            

                
            

            

                
            _ => {}

            

        

            

                4976
            

            

                
            

            

                
        }

            

        

            

                4977
            

            

                
            

            

                
    }

            

        

            

                4978
            

            

                
            

            

                
    return ContextIterWrapper::from(returns.into_iter());

            

        

            

                4979
            

            

                
            

            

                
}

            

        

            

                4980
            

            

                
            

            

                

            

        

            

                4981
            

            

                
            

            

                
// Generated as internal constructor for term truthy.

            

        

            

                4982
            

            

                
            

            

                
pub fn constructor_truthy<C: Context>(

            

        

            

                4983
            

            

                
            

            

                
    ctx: &mut C,

            

        

            

                4984
            

            

                
            

            

                
    arg0: Value,

            

        

            

                4985
            

            

                
            

            

                
) -> impl ContextIter<Context = C, Output = Value> {

            

        

            

                4986
            

            

                
            

            

                
    let mut returns = ConstructorVec::new();

            

        

            

                4987
            

            

                
            

            

                
    let v1 = C::inst_data_etor(ctx, arg0);

            

        

            

                4988
            

            

                
            

            

                
    let mut v1 = v1;

            

        

            

                4989
            

            

                
            

            

                
    while let Some(v2) = v1.next(ctx) {

            

        

            

                4990
            

            

                
            

            

                
        match &v2.1 {

            

        

            

                4991
            

            

                
            

            

                
            &InstructionData::Binary {

            

        

            

                4992
            

            

                
            

            

                
                opcode: ref v7,

            

        

            

                4993
            

            

                
            

            

                
                args: ref v8,

            

        

            

                4994
            

            

                
            

            

                
            } => {

            

        

            

                4995
            

            

                
            

            

                
                match v7 {

            

        

            

                4996
            

            

                
            

            

                
                    &Opcode::Rotl => {

            

        

            

                4997
            

            

                
            

            

                
                        let v9 = C::unpack_value_array_2(ctx, v8);

            

        

            

                4998
            

            

                
            

            

                
                        // Rule at src/opts/bitops.isle line 119.

            

        

            

                4999
            

            

                
            

            

                
                        returns.push(v9.0);

            

        

            

                5000
            

            

                
            

            

                
                    }

            

        

            

                5001
            

            

                
            

            

                
                    &Opcode::Rotr => {

            

        

            

                5002
            

            

                
            

            

                
                        let v9 = C::unpack_value_array_2(ctx, v8);

            

        

            

                5003
            

            

                
            

            

                
                        // Rule at src/opts/bitops.isle line 120.

            

        

            

                5004
            

            

                
            

            

                
                        returns.push(v9.0);

            

        

            

                5005
            

            

                
            

            

                
                    }

            

        

            

                5006
            

            

                
            

            

                
                    _ => {}

            

        

            

                5007
            

            

                
            

            

                
                }

            

        

            

                5008
            

            

                
            

            

                
            }

            

        

            

                5009
            

            

                
            

            

                
            &InstructionData::IntCompare {

            

        

            

                5010
            

            

                
            

            

                
                opcode: ref v33,

            

        

            

                5011
            

            

                
            

            

                
                args: ref v34,

            

        

            

                5012
            

            

                
            

            

                
                cond: ref v35,

            

        

            

                5013
            

            

                
            

            

                
            } => {

            

        

            

                5014
            

            

                
            

            

                
                if let &Opcode::Icmp = v33 {

            

        

            

                5015
            

            

                
            

            

                
                    if let &IntCC::NotEqual = v35 {

            

        

            

                5016
            

            

                
            

            

                
                        let v36 = C::unpack_value_array_2(ctx, v34);

            

        

            

                5017
            

            

                
            

            

                
                        let v39 = C::inst_data_etor(ctx, v36.1);

            

        

            

                5018
            

            

                
            

            

                
                        let mut v39 = v39;

            

        

            

                5019
            

            

                
            

            

                
                        while let Some(v40) = v39.next(ctx) {

            

        

            

                5020
            

            

                
            

            

                
                            if let &InstructionData::UnaryImm {

            

        

            

                5021
            

            

                
            

            

                
                                opcode: ref v43,

            

        

            

                5022
            

            

                
            

            

                
                                imm: v44,

            

        

            

                5023
            

            

                
            

            

                
                            } = &v40.1

            

        

            

                5024
            

            

                
            

            

                
                            {

            

        

            

                5025
            

            

                
            

            

                
                                if let &Opcode::Iconst = v43 {

            

        

            

                5026
            

            

                
            

            

                
                                    let v45 = C::u64_from_imm64(ctx, v44);

            

        

            

                5027
            

            

                
            

            

                
                                    if v45 == 0x0 {

            

        

            

                5028
            

            

                
            

            

                
                                        // Rule at src/opts/bitops.isle line 123.

            

        

            

                5029
            

            

                
            

            

                
                                        returns.push(v36.0);

            

        

            

                5030
            

            

                
            

            

                
                                    }

            

        

            

                5031
            

            

                
            

            

                
                                }

            

        

            

                5032
            

            

                
            

            

                
                            }

            

        

            

                5033
            

            

                
            

            

                
                        }

            

        

            

                5034
            

            

                
            

            

                
                    }

            

        

            

                5035
            

            

                
            

            

                
                }

            

        

            

                5036
            

            

                
            

            

                
            }

            

        

            

                5037
            

            

                
            

            

                
            &InstructionData::Ternary {

            

        

            

                5038
            

            

                
            

            

                
                opcode: ref v12,

            

        

            

                5039
            

            

                
            

            

                
                args: ref v13,

            

        

            

                5040
            

            

                
            

            

                
            } => {

            

        

            

                5041
            

            

                
            

            

                
                if let &Opcode::Select = v12 {

            

        

            

                5042
            

            

                
            

            

                
                    let v14 = C::unpack_value_array_3(ctx, v13);

            

        

            

                5043
            

            

                
            

            

                
                    let v18 = C::inst_data_etor(ctx, v14.1);

            

        

            

                5044
            

            

                
            

            

                
                    let mut v18 = v18;

            

        

            

                5045
            

            

                
            

            

                
                    while let Some(v19) = v18.next(ctx) {

            

        

            

                5046
            

            

                
            

            

                
                        if let &InstructionData::UnaryImm {

            

        

            

                5047
            

            

                
            

            

                
                            opcode: ref v22,

            

        

            

                5048
            

            

                
            

            

                
                            imm: v23,

            

        

            

                5049
            

            

                
            

            

                
                        } = &v19.1

            

        

            

                5050
            

            

                
            

            

                
                        {

            

        

            

                5051
            

            

                
            

            

                
                            if let &Opcode::Iconst = v22 {

            

        

            

                5052
            

            

                
            

            

                
                                let v24 = C::u64_from_imm64(ctx, v23);

            

        

            

                5053
            

            

                
            

            

                
                                let v25 = C::u64_is_zero(ctx, v24);

            

        

            

                5054
            

            

                
            

            

                
                                if v25 == false {

            

        

            

                5055
            

            

                
            

            

                
                                    let v26 = C::inst_data_etor(ctx, v14.2);

            

        

            

                5056
            

            

                
            

            

                
                                    let mut v26 = v26;

            

        

            

                5057
            

            

                
            

            

                
                                    while let Some(v27) = v26.next(ctx) {

            

        

            

                5058
            

            

                
            

            

                
                                        if let &InstructionData::UnaryImm {

            

        

            

                5059
            

            

                
            

            

                
                                            opcode: ref v30,

            

        

            

                5060
            

            

                
            

            

                
                                            imm: v31,

            

        

            

                5061
            

            

                
            

            

                
                                        } = &v27.1

            

        

            

                5062
            

            

                
            

            

                
                                        {

            

        

            

                5063
            

            

                
            

            

                
                                            if let &Opcode::Iconst = v30 {

            

        

            

                5064
            

            

                
            

            

                
                                                let v32 = C::u64_from_imm64(ctx, v31);

            

        

            

                5065
            

            

                
            

            

                
                                                if v32 == 0x0 {

            

        

            

                5066
            

            

                
            

            

                
                                                    // Rule at src/opts/bitops.isle line 121.

            

        

            

                5067
            

            

                
            

            

                
                                                    returns.push(v14.0);

            

        

            

                5068
            

            

                
            

            

                
                                                }

            

        

            

                5069
            

            

                
            

            

                
                                            }

            

        

            

                5070
            

            

                
            

            

                
                                        }

            

        

            

                5071
            

            

                
            

            

                
                                    }

            

        

            

                5072
            

            

                
            

            

                
                                }

            

        

            

                5073
            

            

                
            

            

                
                            }

            

        

            

                5074
            

            

                
            

            

                
                        }

            

        

            

                5075
            

            

                
            

            

                
                    }

            

        

            

                5076
            

            

                
            

            

                
                }

            

        

            

                5077
            

            

                
            

            

                
            }

            

        

            

                5078
            

            

                
            

            

                
            &InstructionData::Unary {

            

        

            

                5079
            

            

                
            

            

                
                opcode: ref v5,

            

        

            

                5080
            

            

                
            

            

                
                arg: v6,

            

        

            

                5081
            

            

                
            

            

                
            } => {

            

        

            

                5082
            

            

                
            

            

                
                match v5 {

            

        

            

                5083
            

            

                
            

            

                
                    &Opcode::Ineg => {

            

        

            

                5084
            

            

                
            

            

                
                        // Rule at src/opts/bitops.isle line 115.

            

        

            

                5085
            

            

                
            

            

                
                        returns.push(v6);

            

        

            

                5086
            

            

                
            

            

                
                    }

            

        

            

                5087
            

            

                
            

            

                
                    &Opcode::Bitrev => {

            

        

            

                5088
            

            

                
            

            

                
                        // Rule at src/opts/bitops.isle line 117.

            

        

            

                5089
            

            

                
            

            

                
                        returns.push(v6);

            

        

            

                5090
            

            

                
            

            

                
                    }

            

        

            

                5091
            

            

                
            

            

                
                    &Opcode::Bswap => {

            

        

            

                5092
            

            

                
            

            

                
                        // Rule at src/opts/bitops.isle line 116.

            

        

            

                5093
            

            

                
            

            

                
                        returns.push(v6);

            

        

            

                5094
            

            

                
            

            

                
                    }

            

        

            

                5095
            

            

                
            

            

                
                    &Opcode::Popcnt => {

            

        

            

                5096
            

            

                
            

            

                
                        // Rule at src/opts/bitops.isle line 118.

            

        

            

                5097
            

            

                
            

            

                
                        returns.push(v6);

            

        

            

                5098
            

            

                
            

            

                
                    }

            

        

            

                5099
            

            

                
            

            

                
                    &Opcode::Bmask => {

            

        

            

                5100
            

            

                
            

            

                
                        // Rule at src/opts/bitops.isle line 114.

            

        

            

                5101
            

            

                
            

            

                
                        returns.push(v6);

            

        

            

                5102
            

            

                
            

            

                
                    }

            

        

            

                5103
            

            

                
            

            

                
                    &Opcode::Uextend => {

            

        

            

                5104
            

            

                
            

            

                
                        // Rule at src/opts/bitops.isle line 113.

            

        

            

                5105
            

            

                
            

            

                
                        returns.push(v6);

            

        

            

                5106
            

            

                
            

            

                
                    }

            

        

            

                5107
            

            

                
            

            

                
                    &Opcode::Sextend => {

            

        

            

                5108
            

            

                
            

            

                
                        // Rule at src/opts/bitops.isle line 112.

            

        

            

                5109
            

            

                
            

            

                
                        returns.push(v6);

            

        

            

                5110
            

            

                
            

            

                
                    }

            

        

            

                5111
            

            

                
            

            

                
                    _ => {}

            

        

            

                5112
            

            

                
            

            

                
                }

            

        

            

                5113
            

            

                
            

            

                
            }

            

        

            

                5114
            

            

                
            

            

                
            _ => {}

            

        

            

                5115
            

            

                
            

            

                
        }

            

        

            

                5116
            

            

                
            

            

                
    }

            

        

            

                5117
            

            

                
            

            

                
    return ContextIterWrapper::from(returns.into_iter());

            

        

            

                5118
            

            

                
            

            

                
}

            

        

            

                5119
            

            

                
            

            

                

            

        

            

                5120
            

            

                
            

            

                
// Generated as internal constructor for term splat8.

            

        

            

                5121
            

            

                
            

            

                
pub fn constructor_splat8<C: Context>(ctx: &mut C, arg0: u64) -> Constant {

            

        

            

                5122
            

            

                
            

            

                
    let v2 = C::u64_shl(ctx, arg0, 0x8);

            

        

            

                5123
            

            

                
            

            

                
    let v3 = C::u64_or(ctx, arg0, v2);

            

        

            

                5124
            

            

                
            

            

                
    let v4 = constructor_splat16(ctx, v3);

            

        

            

                5125
            

            

                
            

            

                
    // Rule at src/opts/cprop.isle line 194.

            

        

            

                5126
            

            

                
            

            

                
    return v4;

            

        

            

                5127
            

            

                
            

            

                
}

            

        

            

                5128
            

            

                
            

            

                

            

        

            

                5129
            

            

                
            

            

                
// Generated as internal constructor for term splat16.

            

        

            

                5130
            

            

                
            

            

                
pub fn constructor_splat16<C: Context>(ctx: &mut C, arg0: u64) -> Constant {

            

        

            

                5131
            

            

                
            

            

                
    let v2 = C::u64_shl(ctx, arg0, 0x10);

            

        

            

                5132
            

            

                
            

            

                
    let v3 = C::u64_or(ctx, arg0, v2);

            

        

            

                5133
            

            

                
            

            

                
    let v4 = constructor_splat32(ctx, v3);

            

        

            

                5134
            

            

                
            

            

                
    // Rule at src/opts/cprop.isle line 196.

            

        

            

                5135
            

            

                
            

            

                
    return v4;

            

        

            

                5136
            

            

                
            

            

                
}

            

        

            

                5137
            

            

                
            

            

                

            

        

            

                5138
            

            

                
            

            

                
// Generated as internal constructor for term splat32.

            

        

            

                5139
            

            

                
            

            

                
pub fn constructor_splat32<C: Context>(ctx: &mut C, arg0: u64) -> Constant {

            

        

            

                5140
            

            

                
            

            

                
    let v2 = C::u64_shl(ctx, arg0, 0x20);

            

        

            

                5141
            

            

                
            

            

                
    let v3 = C::u64_or(ctx, arg0, v2);

            

        

            

                5142
            

            

                
            

            

                
    let v4 = C::splat64(ctx, v3);

            

        

            

                5143
            

            

                
            

            

                
    // Rule at src/opts/cprop.isle line 198.

            

        

            

                5144
            

            

                
            

            

                
    return v4;

            

        

            

                5145
            

            

                
            

            

                
}

            

        

            

                5146
            

            

                
            

            

                

            

        

            

                5147
            

            

                
            

            

                
// Generated as internal constructor for term intcc_comparable.

            

        

            

                5148
            

            

                
            

            

                
pub fn constructor_intcc_comparable<C: Context>(

            

        

            

                5149
            

            

                
            

            

                
    ctx: &mut C,

            

        

            

                5150
            

            

                
            

            

                
    arg0: &IntCC,

            

        

            

                5151
            

            

                
            

            

                
    arg1: &IntCC,

            

        

            

                5152
            

            

                
            

            

                
) -> Option<bool> {

            

        

            

                5153
            

            

                
            

            

                
    let v2 = constructor_intcc_class(ctx, arg0);

            

        

            

                5154
            

            

                
            

            

                
    let v3 = constructor_intcc_class(ctx, arg1);

            

        

            

                5155
            

            

                
            

            

                
    let v4 = C::u64_and(ctx, v2, v3);

            

        

            

                5156
            

            

                
            

            

                
    let v5 = C::u64_is_zero(ctx, v4);

            

        

            

                5157
            

            

                
            

            

                
    if v5 == false {

            

        

            

                5158
            

            

                
            

            

                
        let v7 = C::u64_eq(ctx, 0x2, v4);

            

        

            

                5159
            

            

                
            

            

                
        // Rule at src/opts/icmp.isle line 137.

            

        

            

                5160
            

            

                
            

            

                
        return Some(v7);

            

        

            

                5161
            

            

                
            

            

                
    }

            

        

            

                5162
            

            

                
            

            

                
    None

            

        

            

                5163
            

            

                
            

            

                
}

            

        

            

                5164
            

            

                
            

            

                

            

        

            

                5165
            

            

                
            

            

                
// Generated as internal constructor for term decompose_intcc.

            

        

            

                5166
            

            

                
            

            

                
pub fn constructor_decompose_intcc<C: Context>(ctx: &mut C, arg0: &IntCC) -> u64 {

            

        

            

                5167
            

            

                
            

            

                
    match arg0 {

            

        

            

                5168
            

            

                
            

            

                
        &IntCC::Equal => {

            

        

            

                5169
            

            

                
            

            

                
            // Rule at src/opts/icmp.isle line 142.

            

        

            

                5170
            

            

                
            

            

                
            return 0x1;

            

        

            

                5171
            

            

                
            

            

                
        }

            

        

            

                5172
            

            

                
            

            

                
        &IntCC::NotEqual => {

            

        

            

                5173
            

            

                
            

            

                
            // Rule at src/opts/icmp.isle line 151.

            

        

            

                5174
            

            

                
            

            

                
            return 0x6;

            

        

            

                5175
            

            

                
            

            

                
        }

            

        

            

                5176
            

            

                
            

            

                
        &IntCC::SignedGreaterThan => {

            

        

            

                5177
            

            

                
            

            

                
            // Rule at src/opts/icmp.isle line 148.

            

        

            

                5178
            

            

                
            

            

                
            return 0x4;

            

        

            

                5179
            

            

                
            

            

                
        }

            

        

            

                5180
            

            

                
            

            

                
        &IntCC::SignedGreaterThanOrEqual => {

            

        

            

                5181
            

            

                
            

            

                
            // Rule at src/opts/icmp.isle line 150.

            

        

            

                5182
            

            

                
            

            

                
            return 0x5;

            

        

            

                5183
            

            

                
            

            

                
        }

            

        

            

                5184
            

            

                
            

            

                
        &IntCC::SignedLessThan => {

            

        

            

                5185
            

            

                
            

            

                
            // Rule at src/opts/icmp.isle line 144.

            

        

            

                5186
            

            

                
            

            

                
            return 0x2;

            

        

            

                5187
            

            

                
            

            

                
        }

            

        

            

                5188
            

            

                
            

            

                
        &IntCC::SignedLessThanOrEqual => {

            

        

            

                5189
            

            

                
            

            

                
            // Rule at src/opts/icmp.isle line 146.

            

        

            

                5190
            

            

                
            

            

                
            return 0x3;

            

        

            

                5191
            

            

                
            

            

                
        }

            

        

            

                5192
            

            

                
            

            

                
        &IntCC::UnsignedGreaterThan => {

            

        

            

                5193
            

            

                
            

            

                
            // Rule at src/opts/icmp.isle line 147.

            

        

            

                5194
            

            

                
            

            

                
            return 0x4;

            

        

            

                5195
            

            

                
            

            

                
        }

            

        

            

                5196
            

            

                
            

            

                
        &IntCC::UnsignedGreaterThanOrEqual => {

            

        

            

                5197
            

            

                
            

            

                
            // Rule at src/opts/icmp.isle line 149.

            

        

            

                5198
            

            

                
            

            

                
            return 0x5;

            

        

            

                5199
            

            

                
            

            

                
        }

            

        

            

                5200
            

            

                
            

            

                
        &IntCC::UnsignedLessThan => {

            

        

            

                5201
            

            

                
            

            

                
            // Rule at src/opts/icmp.isle line 143.

            

        

            

                5202
            

            

                
            

            

                
            return 0x2;

            

        

            

                5203
            

            

                
            

            

                
        }

            

        

            

                5204
            

            

                
            

            

                
        &IntCC::UnsignedLessThanOrEqual => {

            

        

            

                5205
            

            

                
            

            

                
            // Rule at src/opts/icmp.isle line 145.

            

        

            

                5206
            

            

                
            

            

                
            return 0x3;

            

        

            

                5207
            

            

                
            

            

                
        }

            

        

            

                5208
            

            

                
            

            

                
        _ => {}

            

        

            

                5209
            

            

                
            

            

                
    }

            

        

            

                5210
            

            

                
            

            

                
    unreachable!(

            

        

            

                5211
            

            

                
            

            

                
        "no rule matched for term {} at {}; should it be partial?",

            

        

            

                5212
            

            

                
            

            

                
        "decompose_intcc", "src/opts/icmp.isle line 141"

            

        

            

                5213
            

            

                
            

            

                
    )

            

        

            

                5214
            

            

                
            

            

                
}

            

        

            

                5215
            

            

                
            

            

                

            

        

            

                5216
            

            

                
            

            

                
// Generated as internal constructor for term compose_icmp.

            

        

            

                5217
            

            

                
            

            

                
pub fn constructor_compose_icmp<C: Context>(

            

        

            

                5218
            

            

                
            

            

                
    ctx: &mut C,

            

        

            

                5219
            

            

                
            

            

                
    arg0: Type,

            

        

            

                5220
            

            

                
            

            

                
    arg1: u64,

            

        

            

                5221
            

            

                
            

            

                
    arg2: bool,

            

        

            

                5222
            

            

                
            

            

                
    arg3: Value,

            

        

            

                5223
            

            

                
            

            

                
    arg4: Value,

            

        

            

                5224
            

            

                
            

            

                
) -> Value {

            

        

            

                5225
            

            

                
            

            

                
    match arg1 {

            

        

            

                5226
            

            

                
            

            

                
        0x0 => {

            

        

            

                5227
            

            

                
            

            

                
            let v6 = C::imm64(ctx, 0x0);

            

        

            

                5228
            

            

                
            

            

                
            let v7 = constructor_iconst(ctx, arg0, v6);

            

        

            

                5229
            

            

                
            

            

                
            let v8 = C::subsume(ctx, v7);

            

        

            

                5230
            

            

                
            

            

                
            // Rule at src/opts/icmp.isle line 154.

            

        

            

                5231
            

            

                
            

            

                
            return v8;

            

        

            

                5232
            

            

                
            

            

                
        }

            

        

            

                5233
            

            

                
            

            

                
        0x1 => {

            

        

            

                5234
            

            

                
            

            

                
            let v10 = constructor_icmp(ctx, arg0, &IntCC::Equal, arg3, arg4);

            

        

            

                5235
            

            

                
            

            

                
            // Rule at src/opts/icmp.isle line 155.

            

        

            

                5236
            

            

                
            

            

                
            return v10;

            

        

            

                5237
            

            

                
            

            

                
        }

            

        

            

                5238
            

            

                
            

            

                
        0x2 => {

            

        

            

                5239
            

            

                
            

            

                
            match arg2 {

            

        

            

                5240
            

            

                
            

            

                
                true => {

            

        

            

                5241
            

            

                
            

            

                
                    let v14 = constructor_icmp(ctx, arg0, &IntCC::SignedLessThan, arg3, arg4);

            

        

            

                5242
            

            

                
            

            

                
                    // Rule at src/opts/icmp.isle line 157.

            

        

            

                5243
            

            

                
            

            

                
                    return v14;

            

        

            

                5244
            

            

                
            

            

                
                }

            

        

            

                5245
            

            

                
            

            

                
                false => {

            

        

            

                5246
            

            

                
            

            

                
                    let v12 = constructor_icmp(ctx, arg0, &IntCC::UnsignedLessThan, arg3, arg4);

            

        

            

                5247
            

            

                
            

            

                
                    // Rule at src/opts/icmp.isle line 156.

            

        

            

                5248
            

            

                
            

            

                
                    return v12;

            

        

            

                5249
            

            

                
            

            

                
                }

            

        

            

                5250
            

            

                
            

            

                
                _ => {}

            

        

            

                5251
            

            

                
            

            

                
            }

            

        

            

                5252
            

            

                
            

            

                
        }

            

        

            

                5253
            

            

                
            

            

                
        0x3 => {

            

        

            

                5254
            

            

                
            

            

                
            match arg2 {

            

        

            

                5255
            

            

                
            

            

                
                true => {

            

        

            

                5256
            

            

                
            

            

                
                    let v18 =

            

        

            

                5257
            

            

                
            

            

                
                        constructor_icmp(ctx, arg0, &IntCC::SignedLessThanOrEqual, arg3, arg4);

            

        

            

                5258
            

            

                
            

            

                
                    // Rule at src/opts/icmp.isle line 159.

            

        

            

                5259
            

            

                
            

            

                
                    return v18;

            

        

            

                5260
            

            

                
            

            

                
                }

            

        

            

                5261
            

            

                
            

            

                
                false => {

            

        

            

                5262
            

            

                
            

            

                
                    let v16 =

            

        

            

                5263
            

            

                
            

            

                
                        constructor_icmp(ctx, arg0, &IntCC::UnsignedLessThanOrEqual, arg3, arg4);

            

        

            

                5264
            

            

                
            

            

                
                    // Rule at src/opts/icmp.isle line 158.

            

        

            

                5265
            

            

                
            

            

                
                    return v16;

            

        

            

                5266
            

            

                
            

            

                
                }

            

        

            

                5267
            

            

                
            

            

                
                _ => {}

            

        

            

                5268
            

            

                
            

            

                
            }

            

        

            

                5269
            

            

                
            

            

                
        }

            

        

            

                5270
            

            

                
            

            

                
        0x4 => {

            

        

            

                5271
            

            

                
            

            

                
            match arg2 {

            

        

            

                5272
            

            

                
            

            

                
                true => {

            

        

            

                5273
            

            

                
            

            

                
                    let v22 = constructor_icmp(ctx, arg0, &IntCC::SignedGreaterThan, arg3, arg4);

            

        

            

                5274
            

            

                
            

            

                
                    // Rule at src/opts/icmp.isle line 161.

            

        

            

                5275
            

            

                
            

            

                
                    return v22;

            

        

            

                5276
            

            

                
            

            

                
                }

            

        

            

                5277
            

            

                
            

            

                
                false => {

            

        

            

                5278
            

            

                
            

            

                
                    let v20 = constructor_icmp(ctx, arg0, &IntCC::UnsignedGreaterThan, arg3, arg4);

            

        

            

                5279
            

            

                
            

            

                
                    // Rule at src/opts/icmp.isle line 160.

            

        

            

                5280
            

            

                
            

            

                
                    return v20;

            

        

            

                5281
            

            

                
            

            

                
                }

            

        

            

                5282
            

            

                
            

            

                
                _ => {}

            

        

            

                5283
            

            

                
            

            

                
            }

            

        

            

                5284
            

            

                
            

            

                
        }

            

        

            

                5285
            

            

                
            

            

                
        0x5 => {

            

        

            

                5286
            

            

                
            

            

                
            match arg2 {

            

        

            

                5287
            

            

                
            

            

                
                true => {

            

        

            

                5288
            

            

                
            

            

                
                    let v26 =

            

        

            

                5289
            

            

                
            

            

                
                        constructor_icmp(ctx, arg0, &IntCC::SignedGreaterThanOrEqual, arg3, arg4);

            

        

            

                5290
            

            

                
            

            

                
                    // Rule at src/opts/icmp.isle line 163.

            

        

            

                5291
            

            

                
            

            

                
                    return v26;

            

        

            

                5292
            

            

                
            

            

                
                }

            

        

            

                5293
            

            

                
            

            

                
                false => {

            

        

            

                5294
            

            

                
            

            

                
                    let v24 =

            

        

            

                5295
            

            

                
            

            

                
                        constructor_icmp(ctx, arg0, &IntCC::UnsignedGreaterThanOrEqual, arg3, arg4);

            

        

            

                5296
            

            

                
            

            

                
                    // Rule at src/opts/icmp.isle line 162.

            

        

            

                5297
            

            

                
            

            

                
                    return v24;

            

        

            

                5298
            

            

                
            

            

                
                }

            

        

            

                5299
            

            

                
            

            

                
                _ => {}

            

        

            

                5300
            

            

                
            

            

                
            }

            

        

            

                5301
            

            

                
            

            

                
        }

            

        

            

                5302
            

            

                
            

            

                
        0x6 => {

            

        

            

                5303
            

            

                
            

            

                
            let v28 = constructor_icmp(ctx, arg0, &IntCC::NotEqual, arg3, arg4);

            

        

            

                5304
            

            

                
            

            

                
            // Rule at src/opts/icmp.isle line 164.

            

        

            

                5305
            

            

                
            

            

                
            return v28;

            

        

            

                5306
            

            

                
            

            

                
        }

            

        

            

                5307
            

            

                
            

            

                
        0x7 => {

            

        

            

                5308
            

            

                
            

            

                
            let v30 = C::imm64(ctx, 0x1);

            

        

            

                5309
            

            

                
            

            

                
            let v31 = constructor_iconst(ctx, arg0, v30);

            

        

            

                5310
            

            

                
            

            

                
            let v32 = C::subsume(ctx, v31);

            

        

            

                5311
            

            

                
            

            

                
            // Rule at src/opts/icmp.isle line 165.

            

        

            

                5312
            

            

                
            

            

                
            return v32;

            

        

            

                5313
            

            

                
            

            

                
        }

            

        

            

                5314
            

            

                
            

            

                
        _ => {}

            

        

            

                5315
            

            

                
            

            

                
    }

            

        

            

                5316
            

            

                
            

            

                
    unreachable!(

            

        

            

                5317
            

            

                
            

            

                
        "no rule matched for term {} at {}; should it be partial?",

            

        

            

                5318
            

            

                
            

            

                
        "compose_icmp", "src/opts/icmp.isle line 153"

            

        

            

                5319
            

            

                
            

            

                
    )

            

        

            

                5320
            

            

                
            

            

                
}

            

        

            

                5321
            

            

                
            

            

                

            

        

            

                5322
            

            

                
            

            

                
// Generated as internal constructor for term intcc_class.

            

        

            

                5323
            

            

                
            

            

                
pub fn constructor_intcc_class<C: Context>(ctx: &mut C, arg0: &IntCC) -> u64 {

            

        

            

                5324
            

            

                
            

            

                
    match arg0 {

            

        

            

                5325
            

            

                
            

            

                
        &IntCC::Equal => {

            

        

            

                5326
            

            

                
            

            

                
            // Rule at src/opts/icmp.isle line 176.

            

        

            

                5327
            

            

                
            

            

                
            return 0x3;

            

        

            

                5328
            

            

                
            

            

                
        }

            

        

            

                5329
            

            

                
            

            

                
        &IntCC::NotEqual => {

            

        

            

                5330
            

            

                
            

            

                
            // Rule at src/opts/icmp.isle line 177.

            

        

            

                5331
            

            

                
            

            

                
            return 0x3;

            

        

            

                5332
            

            

                
            

            

                
        }

            

        

            

                5333
            

            

                
            

            

                
        &IntCC::SignedGreaterThan => {

            

        

            

                5334
            

            

                
            

            

                
            // Rule at src/opts/icmp.isle line 174.

            

        

            

                5335
            

            

                
            

            

                
            return 0x2;

            

        

            

                5336
            

            

                
            

            

                
        }

            

        

            

                5337
            

            

                
            

            

                
        &IntCC::SignedGreaterThanOrEqual => {

            

        

            

                5338
            

            

                
            

            

                
            // Rule at src/opts/icmp.isle line 175.

            

        

            

                5339
            

            

                
            

            

                
            return 0x2;

            

        

            

                5340
            

            

                
            

            

                
        }

            

        

            

                5341
            

            

                
            

            

                
        &IntCC::SignedLessThan => {

            

        

            

                5342
            

            

                
            

            

                
            // Rule at src/opts/icmp.isle line 172.

            

        

            

                5343
            

            

                
            

            

                
            return 0x2;

            

        

            

                5344
            

            

                
            

            

                
        }

            

        

            

                5345
            

            

                
            

            

                
        &IntCC::SignedLessThanOrEqual => {

            

        

            

                5346
            

            

                
            

            

                
            // Rule at src/opts/icmp.isle line 173.

            

        

            

                5347
            

            

                
            

            

                
            return 0x2;

            

        

            

                5348
            

            

                
            

            

                
        }

            

        

            

                5349
            

            

                
            

            

                
        &IntCC::UnsignedGreaterThan => {

            

        

            

                5350
            

            

                
            

            

                
            // Rule at src/opts/icmp.isle line 170.

            

        

            

                5351
            

            

                
            

            

                
            return 0x1;

            

        

            

                5352
            

            

                
            

            

                
        }

            

        

            

                5353
            

            

                
            

            

                
        &IntCC::UnsignedGreaterThanOrEqual => {

            

        

            

                5354
            

            

                
            

            

                
            // Rule at src/opts/icmp.isle line 171.

            

        

            

                5355
            

            

                
            

            

                
            return 0x1;

            

        

            

                5356
            

            

                
            

            

                
        }

            

        

            

                5357
            

            

                
            

            

                
        &IntCC::UnsignedLessThan => {

            

        

            

                5358
            

            

                
            

            

                
            // Rule at src/opts/icmp.isle line 168.

            

        

            

                5359
            

            

                
            

            

                
            return 0x1;

            

        

            

                5360
            

            

                
            

            

                
        }

            

        

            

                5361
            

            

                
            

            

                
        &IntCC::UnsignedLessThanOrEqual => {

            

        

            

                5362
            

            

                
            

            

                
            // Rule at src/opts/icmp.isle line 169.

            

        

            

                5363
            

            

                
            

            

                
            return 0x1;

            

        

            

                5364
            

            

                
            

            

                
        }

            

        

            

                5365
            

            

                
            

            

                
        _ => {}

            

        

            

                5366
            

            

                
            

            

                
    }

            

        

            

                5367
            

            

                
            

            

                
    unreachable!(

            

        

            

                5368
            

            

                
            

            

                
        "no rule matched for term {} at {}; should it be partial?",

            

        

            

                5369
            

            

                
            

            

                
        "intcc_class", "src/opts/icmp.isle line 167"

            

        

            

                5370
            

            

                
            

            

                
    )

            

        

            

                5371
            

            

                
            

            

                
}

            

        

            

                5372
            

            

                
            

            

                

            

        

            

                5373
            

            

                
            

            

                
// Generated as internal constructor for term shift_amt_to_type.

            

        

            

                5374
            

            

                
            

            

                
pub fn constructor_shift_amt_to_type<C: Context>(ctx: &mut C, arg0: u64) -> Option<Type> {

            

        

            

                5375
            

            

                
            

            

                
    match arg0 {

            

        

            

                5376
            

            

                
            

            

                
        0x8 => {

            

        

            

                5377
            

            

                
            

            

                
            // Rule at src/opts/shifts.isle line 97.

            

        

            

                5378
            

            

                
            

            

                
            return Some(I8);

            

        

            

                5379
            

            

                
            

            

                
        }

            

        

            

                5380
            

            

                
            

            

                
        0x10 => {

            

        

            

                5381
            

            

                
            

            

                
            // Rule at src/opts/shifts.isle line 98.

            

        

            

                5382
            

            

                
            

            

                
            return Some(I16);

            

        

            

                5383
            

            

                
            

            

                
        }

            

        

            

                5384
            

            

                
            

            

                
        0x20 => {

            

        

            

                5385
            

            

                
            

            

                
            // Rule at src/opts/shifts.isle line 99.

            

        

            

                5386
            

            

                
            

            

                
            return Some(I32);

            

        

            

                5387
            

            

                
            

            

                
        }

            

        

            

                5388
            

            

                
            

            

                
        _ => {}

            

        

            

                5389
            

            

                
            

            

                
    }

            

        

            

                5390
            

            

                
            

            

                
    None

            

        

            

                5391
            

            

                
            

            

                
}

            

        

            

                5392
            

            

                
            

            

                

            

        

            

                5393
            

            

                
            

            

                
// Generated as internal constructor for term func_addr.

            

        

            

                5394
            

            

                
            

            

                
pub fn constructor_func_addr<C: Context>(ctx: &mut C, arg0: Type, arg1: FuncRef) -> Value {

            

        

            

                5395
            

            

                
            

            

                
    let v3 = InstructionData::FuncAddr {

            

        

            

                5396
            

            

                
            

            

                
        opcode: Opcode::FuncAddr,

            

        

            

                5397
            

            

                
            

            

                
        func_ref: arg1,

            

        

            

                5398
            

            

                
            

            

                
    };

            

        

            

                5399
            

            

                
            

            

                
    let v4 = C::make_inst_ctor(ctx, arg0, &v3);

            

        

            

                5400
            

            

                
            

            

                
    // Rule at /home/smcdev/zk-client-private/near/target/debug/build/cranelift-codegen-c1a82fb675b6a305/out/clif_opt.isle line 361.

            

        

            

                5401
            

            

                
            

            

                
    return v4;

            

        

            

                5402
            

            

                
            

            

                
}

            

        

            

                5403
            

            

                
            

            

                

            

        

            

                5404
            

            

                
            

            

                
// Generated as internal constructor for term splat.

            

        

            

                5405
            

            

                
            

            

                
pub fn constructor_splat<C: Context>(ctx: &mut C, arg0: Type, arg1: Value) -> Value {

            

        

            

                5406
            

            

                
            

            

                
    let v3 = InstructionData::Unary {

            

        

            

                5407
            

            

                
            

            

                
        opcode: Opcode::Splat,

            

        

            

                5408
            

            

                
            

            

                
        arg: arg1,

            

        

            

                5409
            

            

                
            

            

                
    };

            

        

            

                5410
            

            

                
            

            

                
    let v4 = C::make_inst_ctor(ctx, arg0, &v3);

            

        

            

                5411
            

            

                
            

            

                
    // Rule at /home/smcdev/zk-client-private/near/target/debug/build/cranelift-codegen-c1a82fb675b6a305/out/clif_opt.isle line 370.

            

        

            

                5412
            

            

                
            

            

                
    return v4;

            

        

            

                5413
            

            

                
            

            

                
}

            

        

            

                5414
            

            

                
            

            

                

            

        

            

                5415
            

            

                
            

            

                
// Generated as internal constructor for term swizzle.

            

        

            

                5416
            

            

                
            

            

                
pub fn constructor_swizzle<C: Context>(ctx: &mut C, arg0: Type, arg1: Value, arg2: Value) -> Value {

            

        

            

                5417
            

            

                
            

            

                
    let v4 = &C::value_array_2_ctor(ctx, arg1, arg2);

            

        

            

                5418
            

            

                
            

            

                
    let v5 = InstructionData::Binary {

            

        

            

                5419
            

            

                
            

            

                
        opcode: Opcode::Swizzle,

            

        

            

                5420
            

            

                
            

            

                
        args: v4.clone(),

            

        

            

                5421
            

            

                
            

            

                
    };

            

        

            

                5422
            

            

                
            

            

                
    let v6 = C::make_inst_ctor(ctx, arg0, &v5);

            

        

            

                5423
            

            

                
            

            

                
    // Rule at /home/smcdev/zk-client-private/near/target/debug/build/cranelift-codegen-c1a82fb675b6a305/out/clif_opt.isle line 379.

            

        

            

                5424
            

            

                
            

            

                
    return v6;

            

        

            

                5425
            

            

                
            

            

                
}

            

        

            

                5426
            

            

                
            

            

                

            

        

            

                5427
            

            

                
            

            

                
// Generated as internal constructor for term x86_pshufb.

            

        

            

                5428
            

            

                
            

            

                
pub fn constructor_x86_pshufb<C: Context>(

            

        

            

                5429
            

            

                
            

            

                
    ctx: &mut C,

            

        

            

                5430
            

            

                
            

            

                
    arg0: Type,

            

        

            

                5431
            

            

                
            

            

                
    arg1: Value,

            

        

            

                5432
            

            

                
            

            

                
    arg2: Value,

            

        

            

                5433
            

            

                
            

            

                
) -> Value {

            

        

            

                5434
            

            

                
            

            

                
    let v4 = &C::value_array_2_ctor(ctx, arg1, arg2);

            

        

            

                5435
            

            

                
            

            

                
    let v5 = InstructionData::Binary {

            

        

            

                5436
            

            

                
            

            

                
        opcode: Opcode::X86Pshufb,

            

        

            

                5437
            

            

                
            

            

                
        args: v4.clone(),

            

        

            

                5438
            

            

                
            

            

                
    };

            

        

            

                5439
            

            

                
            

            

                
    let v6 = C::make_inst_ctor(ctx, arg0, &v5);

            

        

            

                5440
            

            

                
            

            

                
    // Rule at /home/smcdev/zk-client-private/near/target/debug/build/cranelift-codegen-c1a82fb675b6a305/out/clif_opt.isle line 388.

            

        

            

                5441
            

            

                
            

            

                
    return v6;

            

        

            

                5442
            

            

                
            

            

                
}

            

        

            

                5443
            

            

                
            

            

                

            

        

            

                5444
            

            

                
            

            

                
// Generated as internal constructor for term insertlane.

            

        

            

                5445
            

            

                
            

            

                
pub fn constructor_insertlane<C: Context>(

            

        

            

                5446
            

            

                
            

            

                
    ctx: &mut C,

            

        

            

                5447
            

            

                
            

            

                
    arg0: Type,

            

        

            

                5448
            

            

                
            

            

                
    arg1: Value,

            

        

            

                5449
            

            

                
            

            

                
    arg2: Value,

            

        

            

                5450
            

            

                
            

            

                
    arg3: Uimm8,

            

        

            

                5451
            

            

                
            

            

                
) -> Value {

            

        

            

                5452
            

            

                
            

            

                
    let v5 = &C::value_array_2_ctor(ctx, arg1, arg2);

            

        

            

                5453
            

            

                
            

            

                
    let v6 = InstructionData::TernaryImm8 {

            

        

            

                5454
            

            

                
            

            

                
        opcode: Opcode::Insertlane,

            

        

            

                5455
            

            

                
            

            

                
        args: v5.clone(),

            

        

            

                5456
            

            

                
            

            

                
        imm: arg3,

            

        

            

                5457
            

            

                
            

            

                
    };

            

        

            

                5458
            

            

                
            

            

                
    let v7 = C::make_inst_ctor(ctx, arg0, &v6);

            

        

            

                5459
            

            

                
            

            

                
    // Rule at /home/smcdev/zk-client-private/near/target/debug/build/cranelift-codegen-c1a82fb675b6a305/out/clif_opt.isle line 397.

            

        

            

                5460
            

            

                
            

            

                
    return v7;

            

        

            

                5461
            

            

                
            

            

                
}

            

        

            

                5462
            

            

                
            

            

                

            

        

            

                5463
            

            

                
            

            

                
// Generated as internal constructor for term extractlane.

            

        

            

                5464
            

            

                
            

            

                
pub fn constructor_extractlane<C: Context>(

            

        

            

                5465
            

            

                
            

            

                
    ctx: &mut C,

            

        

            

                5466
            

            

                
            

            

                
    arg0: Type,

            

        

            

                5467
            

            

                
            

            

                
    arg1: Value,

            

        

            

                5468
            

            

                
            

            

                
    arg2: Uimm8,

            

        

            

                5469
            

            

                
            

            

                
) -> Value {

            

        

            

                5470
            

            

                
            

            

                
    let v4 = InstructionData::BinaryImm8 {

            

        

            

                5471
            

            

                
            

            

                
        opcode: Opcode::Extractlane,

            

        

            

                5472
            

            

                
            

            

                
        arg: arg1,

            

        

            

                5473
            

            

                
            

            

                
        imm: arg2,

            

        

            

                5474
            

            

                
            

            

                
    };

            

        

            

                5475
            

            

                
            

            

                
    let v5 = C::make_inst_ctor(ctx, arg0, &v4);

            

        

            

                5476
            

            

                
            

            

                
    // Rule at /home/smcdev/zk-client-private/near/target/debug/build/cranelift-codegen-c1a82fb675b6a305/out/clif_opt.isle line 406.

            

        

            

                5477
            

            

                
            

            

                
    return v5;

            

        

            

                5478
            

            

                
            

            

                
}

            

        

            

                5479
            

            

                
            

            

                

            

        

            

                5480
            

            

                
            

            

                
// Generated as internal constructor for term smin.

            

        

            

                5481
            

            

                
            

            

                
pub fn constructor_smin<C: Context>(ctx: &mut C, arg0: Type, arg1: Value, arg2: Value) -> Value {

            

        

            

                5482
            

            

                
            

            

                
    let v4 = &C::value_array_2_ctor(ctx, arg1, arg2);

            

        

            

                5483
            

            

                
            

            

                
    let v5 = InstructionData::Binary {

            

        

            

                5484
            

            

                
            

            

                
        opcode: Opcode::Smin,

            

        

            

                5485
            

            

                
            

            

                
        args: v4.clone(),

            

        

            

                5486
            

            

                
            

            

                
    };

            

        

            

                5487
            

            

                
            

            

                
    let v6 = C::make_inst_ctor(ctx, arg0, &v5);

            

        

            

                5488
            

            

                
            

            

                
    // Rule at /home/smcdev/zk-client-private/near/target/debug/build/cranelift-codegen-c1a82fb675b6a305/out/clif_opt.isle line 415.

            

        

            

                5489
            

            

                
            

            

                
    return v6;

            

        

            

                5490
            

            

                
            

            

                
}

            

        

            

                5491
            

            

                
            

            

                

            

        

            

                5492
            

            

                
            

            

                
// Generated as internal constructor for term umin.

            

        

            

                5493
            

            

                
            

            

                
pub fn constructor_umin<C: Context>(ctx: &mut C, arg0: Type, arg1: Value, arg2: Value) -> Value {

            

        

            

                5494
            

            

                
            

            

                
    let v4 = &C::value_array_2_ctor(ctx, arg1, arg2);

            

        

            

                5495
            

            

                
            

            

                
    let v5 = InstructionData::Binary {

            

        

            

                5496
            

            

                
            

            

                
        opcode: Opcode::Umin,

            

        

            

                5497
            

            

                
            

            

                
        args: v4.clone(),

            

        

            

                5498
            

            

                
            

            

                
    };

            

        

            

                5499
            

            

                
            

            

                
    let v6 = C::make_inst_ctor(ctx, arg0, &v5);

            

        

            

                5500
            

            

                
            

            

                
    // Rule at /home/smcdev/zk-client-private/near/target/debug/build/cranelift-codegen-c1a82fb675b6a305/out/clif_opt.isle line 424.

            

        

            

                5501
            

            

                
            

            

                
    return v6;

            

        

            

                5502
            

            

                
            

            

                
}

            

        

            

                5503
            

            

                
            

            

                

            

        

            

                5504
            

            

                
            

            

                
// Generated as internal constructor for term smax.

            

        

            

                5505
            

            

                
            

            

                
pub fn constructor_smax<C: Context>(ctx: &mut C, arg0: Type, arg1: Value, arg2: Value) -> Value {

            

        

            

                5506
            

            

                
            

            

                
    let v4 = &C::value_array_2_ctor(ctx, arg1, arg2);

            

        

            

                5507
            

            

                
            

            

                
    let v5 = InstructionData::Binary {

            

        

            

                5508
            

            

                
            

            

                
        opcode: Opcode::Smax,

            

        

            

                5509
            

            

                
            

            

                
        args: v4.clone(),

            

        

            

                5510
            

            

                
            

            

                
    };

            

        

            

                5511
            

            

                
            

            

                
    let v6 = C::make_inst_ctor(ctx, arg0, &v5);

            

        

            

                5512
            

            

                
            

            

                
    // Rule at /home/smcdev/zk-client-private/near/target/debug/build/cranelift-codegen-c1a82fb675b6a305/out/clif_opt.isle line 433.

            

        

            

                5513
            

            

                
            

            

                
    return v6;

            

        

            

                5514
            

            

                
            

            

                
}

            

        

            

                5515
            

            

                
            

            

                

            

        

            

                5516
            

            

                
            

            

                
// Generated as internal constructor for term umax.

            

        

            

                5517
            

            

                
            

            

                
pub fn constructor_umax<C: Context>(ctx: &mut C, arg0: Type, arg1: Value, arg2: Value) -> Value {

            

        

            

                5518
            

            

                
            

            

                
    let v4 = &C::value_array_2_ctor(ctx, arg1, arg2);

            

        

            

                5519
            

            

                
            

            

                
    let v5 = InstructionData::Binary {

            

        

            

                5520
            

            

                
            

            

                
        opcode: Opcode::Umax,

            

        

            

                5521
            

            

                
            

            

                
        args: v4.clone(),

            

        

            

                5522
            

            

                
            

            

                
    };

            

        

            

                5523
            

            

                
            

            

                
    let v6 = C::make_inst_ctor(ctx, arg0, &v5);

            

        

            

                5524
            

            

                
            

            

                
    // Rule at /home/smcdev/zk-client-private/near/target/debug/build/cranelift-codegen-c1a82fb675b6a305/out/clif_opt.isle line 442.

            

        

            

                5525
            

            

                
            

            

                
    return v6;

            

        

            

                5526
            

            

                
            

            

                
}

            

        

            

                5527
            

            

                
            

            

                

            

        

            

                5528
            

            

                
            

            

                
// Generated as internal constructor for term avg_round.

            

        

            

                5529
            

            

                
            

            

                
pub fn constructor_avg_round<C: Context>(

            

        

            

                5530
            

            

                
            

            

                
    ctx: &mut C,

            

        

            

                5531
            

            

                
            

            

                
    arg0: Type,

            

        

            

                5532
            

            

                
            

            

                
    arg1: Value,

            

        

            

                5533
            

            

                
            

            

                
    arg2: Value,

            

        

            

                5534
            

            

                
            

            

                
) -> Value {

            

        

            

                5535
            

            

                
            

            

                
    let v4 = &C::value_array_2_ctor(ctx, arg1, arg2);

            

        

            

                5536
            

            

                
            

            

                
    let v5 = InstructionData::Binary {

            

        

            

                5537
            

            

                
            

            

                
        opcode: Opcode::AvgRound,

            

        

            

                5538
            

            

                
            

            

                
        args: v4.clone(),

            

        

            

                5539
            

            

                
            

            

                
    };

            

        

            

                5540
            

            

                
            

            

                
    let v6 = C::make_inst_ctor(ctx, arg0, &v5);

            

        

            

                5541
            

            

                
            

            

                
    // Rule at /home/smcdev/zk-client-private/near/target/debug/build/cranelift-codegen-c1a82fb675b6a305/out/clif_opt.isle line 451.

            

        

            

                5542
            

            

                
            

            

                
    return v6;

            

        

            

                5543
            

            

                
            

            

                
}

            

        

            

                5544
            

            

                
            

            

                

            

        

            

                5545
            

            

                
            

            

                
// Generated as internal constructor for term uadd_sat.

            

        

            

                5546
            

            

                
            

            

                
pub fn constructor_uadd_sat<C: Context>(

            

        

            

                5547
            

            

                
            

            

                
    ctx: &mut C,

            

        

            

                5548
            

            

                
            

            

                
    arg0: Type,

            

        

            

                5549
            

            

                
            

            

                
    arg1: Value,

            

        

            

                5550
            

            

                
            

            

                
    arg2: Value,

            

        

            

                5551
            

            

                
            

            

                
) -> Value {

            

        

            

                5552
            

            

                
            

            

                
    let v4 = &C::value_array_2_ctor(ctx, arg1, arg2);

            

        

            

                5553
            

            

                
            

            

                
    let v5 = InstructionData::Binary {

            

        

            

                5554
            

            

                
            

            

                
        opcode: Opcode::UaddSat,

            

        

            

                5555
            

            

                
            

            

                
        args: v4.clone(),

            

        

            

                5556
            

            

                
            

            

                
    };

            

        

            

                5557
            

            

                
            

            

                
    let v6 = C::make_inst_ctor(ctx, arg0, &v5);

            

        

            

                5558
            

            

                
            

            

                
    // Rule at /home/smcdev/zk-client-private/near/target/debug/build/cranelift-codegen-c1a82fb675b6a305/out/clif_opt.isle line 460.

            

        

            

                5559
            

            

                
            

            

                
    return v6;

            

        

            

                5560
            

            

                
            

            

                
}

            

        

            

                5561
            

            

                
            

            

                

            

        

            

                5562
            

            

                
            

            

                
// Generated as internal constructor for term sadd_sat.

            

        

            

                5563
            

            

                
            

            

                
pub fn constructor_sadd_sat<C: Context>(

            

        

            

                5564
            

            

                
            

            

                
    ctx: &mut C,

            

        

            

                5565
            

            

                
            

            

                
    arg0: Type,

            

        

            

                5566
            

            

                
            

            

                
    arg1: Value,

            

        

            

                5567
            

            

                
            

            

                
    arg2: Value,

            

        

            

                5568
            

            

                
            

            

                
) -> Value {

            

        

            

                5569
            

            

                
            

            

                
    let v4 = &C::value_array_2_ctor(ctx, arg1, arg2);

            

        

            

                5570
            

            

                
            

            

                
    let v5 = InstructionData::Binary {

            

        

            

                5571
            

            

                
            

            

                
        opcode: Opcode::SaddSat,

            

        

            

                5572
            

            

                
            

            

                
        args: v4.clone(),

            

        

            

                5573
            

            

                
            

            

                
    };

            

        

            

                5574
            

            

                
            

            

                
    let v6 = C::make_inst_ctor(ctx, arg0, &v5);

            

        

            

                5575
            

            

                
            

            

                
    // Rule at /home/smcdev/zk-client-private/near/target/debug/build/cranelift-codegen-c1a82fb675b6a305/out/clif_opt.isle line 469.

            

        

            

                5576
            

            

                
            

            

                
    return v6;

            

        

            

                5577
            

            

                
            

            

                
}

            

        

            

                5578
            

            

                
            

            

                

            

        

            

                5579
            

            

                
            

            

                
// Generated as internal constructor for term usub_sat.

            

        

            

                5580
            

            

                
            

            

                
pub fn constructor_usub_sat<C: Context>(

            

        

            

                5581
            

            

                
            

            

                
    ctx: &mut C,

            

        

            

                5582
            

            

                
            

            

                
    arg0: Type,

            

        

            

                5583
            

            

                
            

            

                
    arg1: Value,

            

        

            

                5584
            

            

                
            

            

                
    arg2: Value,

            

        

            

                5585
            

            

                
            

            

                
) -> Value {

            

        

            

                5586
            

            

                
            

            

                
    let v4 = &C::value_array_2_ctor(ctx, arg1, arg2);

            

        

            

                5587
            

            

                
            

            

                
    let v5 = InstructionData::Binary {

            

        

            

                5588
            

            

                
            

            

                
        opcode: Opcode::UsubSat,

            

        

            

                5589
            

            

                
            

            

                
        args: v4.clone(),

            

        

            

                5590
            

            

                
            

            

                
    };

            

        

            

                5591
            

            

                
            

            

                
    let v6 = C::make_inst_ctor(ctx, arg0, &v5);

            

        

            

                5592
            

            

                
            

            

                
    // Rule at /home/smcdev/zk-client-private/near/target/debug/build/cranelift-codegen-c1a82fb675b6a305/out/clif_opt.isle line 478.

            

        

            

                5593
            

            

                
            

            

                
    return v6;

            

        

            

                5594
            

            

                
            

            

                
}

            

        

            

                5595
            

            

                
            

            

                

            

        

            

                5596
            

            

                
            

            

                
// Generated as internal constructor for term ssub_sat.

            

        

            

                5597
            

            

                
            

            

                
pub fn constructor_ssub_sat<C: Context>(

            

        

            

                5598
            

            

                
            

            

                
    ctx: &mut C,

            

        

            

                5599
            

            

                
            

            

                
    arg0: Type,

            

        

            

                5600
            

            

                
            

            

                
    arg1: Value,

            

        

            

                5601
            

            

                
            

            

                
    arg2: Value,

            

        

            

                5602
            

            

                
            

            

                
) -> Value {

            

        

            

                5603
            

            

                
            

            

                
    let v4 = &C::value_array_2_ctor(ctx, arg1, arg2);

            

        

            

                5604
            

            

                
            

            

                
    let v5 = InstructionData::Binary {

            

        

            

                5605
            

            

                
            

            

                
        opcode: Opcode::SsubSat,

            

        

            

                5606
            

            

                
            

            

                
        args: v4.clone(),

            

        

            

                5607
            

            

                
            

            

                
    };

            

        

            

                5608
            

            

                
            

            

                
    let v6 = C::make_inst_ctor(ctx, arg0, &v5);

            

        

            

                5609
            

            

                
            

            

                
    // Rule at /home/smcdev/zk-client-private/near/target/debug/build/cranelift-codegen-c1a82fb675b6a305/out/clif_opt.isle line 487.

            

        

            

                5610
            

            

                
            

            

                
    return v6;

            

        

            

                5611
            

            

                
            

            

                
}

            

        

            

                5612
            

            

                
            

            

                

            

        

            

                5613
            

            

                
            

            

                
// Generated as internal constructor for term load.

            

        

            

                5614
            

            

                
            

            

                
pub fn constructor_load<C: Context>(

            

        

            

                5615
            

            

                
            

            

                
    ctx: &mut C,

            

        

            

                5616
            

            

                
            

            

                
    arg0: Type,

            

        

            

                5617
            

            

                
            

            

                
    arg1: MemFlags,

            

        

            

                5618
            

            

                
            

            

                
    arg2: Value,

            

        

            

                5619
            

            

                
            

            

                
    arg3: Offset32,

            

        

            

                5620
            

            

                
            

            

                
) -> Value {

            

        

            

                5621
            

            

                
            

            

                
    let v5 = InstructionData::Load {

            

        

            

                5622
            

            

                
            

            

                
        opcode: Opcode::Load,

            

        

            

                5623
            

            

                
            

            

                
        arg: arg2,

            

        

            

                5624
            

            

                
            

            

                
        flags: arg1,

            

        

            

                5625
            

            

                
            

            

                
        offset: arg3,

            

        

            

                5626
            

            

                
            

            

                
    };

            

        

            

                5627
            

            

                
            

            

                
    let v6 = C::make_inst_ctor(ctx, arg0, &v5);

            

        

            

                5628
            

            

                
            

            

                
    // Rule at /home/smcdev/zk-client-private/near/target/debug/build/cranelift-codegen-c1a82fb675b6a305/out/clif_opt.isle line 496.

            

        

            

                5629
            

            

                
            

            

                
    return v6;

            

        

            

                5630
            

            

                
            

            

                
}

            

        

            

                5631
            

            

                
            

            

                

            

        

            

                5632
            

            

                
            

            

                
// Generated as internal constructor for term uload8.

            

        

            

                5633
            

            

                
            

            

                
pub fn constructor_uload8<C: Context>(

            

        

            

                5634
            

            

                
            

            

                
    ctx: &mut C,

            

        

            

                5635
            

            

                
            

            

                
    arg0: Type,

            

        

            

                5636
            

            

                
            

            

                
    arg1: MemFlags,

            

        

            

                5637
            

            

                
            

            

                
    arg2: Value,

            

        

            

                5638
            

            

                
            

            

                
    arg3: Offset32,

            

        

            

                5639
            

            

                
            

            

                
) -> Value {

            

        

            

                5640
            

            

                
            

            

                
    let v5 = InstructionData::Load {

            

        

            

                5641
            

            

                
            

            

                
        opcode: Opcode::Uload8,

            

        

            

                5642
            

            

                
            

            

                
        arg: arg2,

            

        

            

                5643
            

            

                
            

            

                
        flags: arg1,

            

        

            

                5644
            

            

                
            

            

                
        offset: arg3,

            

        

            

                5645
            

            

                
            

            

                
    };

            

        

            

                5646
            

            

                
            

            

                
    let v6 = C::make_inst_ctor(ctx, arg0, &v5);

            

        

            

                5647
            

            

                
            

            

                
    // Rule at /home/smcdev/zk-client-private/near/target/debug/build/cranelift-codegen-c1a82fb675b6a305/out/clif_opt.isle line 505.

            

        

            

                5648
            

            

                
            

            

                
    return v6;

            

        

            

                5649
            

            

                
            

            

                
}

            

        

            

                5650
            

            

                
            

            

                

            

        

            

                5651
            

            

                
            

            

                
// Generated as internal constructor for term sload8.

            

        

            

                5652
            

            

                
            

            

                
pub fn constructor_sload8<C: Context>(

            

        

            

                5653
            

            

                
            

            

                
    ctx: &mut C,

            

        

            

                5654
            

            

                
            

            

                
    arg0: Type,

            

        

            

                5655
            

            

                
            

            

                
    arg1: MemFlags,

            

        

            

                5656
            

            

                
            

            

                
    arg2: Value,

            

        

            

                5657
            

            

                
            

            

                
    arg3: Offset32,

            

        

            

                5658
            

            

                
            

            

                
) -> Value {

            

        

            

                5659
            

            

                
            

            

                
    let v5 = InstructionData::Load {

            

        

            

                5660
            

            

                
            

            

                
        opcode: Opcode::Sload8,

            

        

            

                5661
            

            

                
            

            

                
        arg: arg2,

            

        

            

                5662
            

            

                
            

            

                
        flags: arg1,

            

        

            

                5663
            

            

                
            

            

                
        offset: arg3,

            

        

            

                5664
            

            

                
            

            

                
    };

            

        

            

                5665
            

            

                
            

            

                
    let v6 = C::make_inst_ctor(ctx, arg0, &v5);

            

        

            

                5666
            

            

                
            

            

                
    // Rule at /home/smcdev/zk-client-private/near/target/debug/build/cranelift-codegen-c1a82fb675b6a305/out/clif_opt.isle line 514.

            

        

            

                5667
            

            

                
            

            

                
    return v6;

            

        

            

                5668
            

            

                
            

            

                
}

            

        

            

                5669
            

            

                
            

            

                

            

        

            

                5670
            

            

                
            

            

                
// Generated as internal constructor for term uload16.

            

        

            

                5671
            

            

                
            

            

                
pub fn constructor_uload16<C: Context>(

            

        

            

                5672
            

            

                
            

            

                
    ctx: &mut C,

            

        

            

                5673
            

            

                
            

            

                
    arg0: Type,

            

        

            

                5674
            

            

                
            

            

                
    arg1: MemFlags,

            

        

            

                5675
            

            

                
            

            

                
    arg2: Value,

            

        

            

                5676
            

            

                
            

            

                
    arg3: Offset32,

            

        

            

                5677
            

            

                
            

            

                
) -> Value {

            

        

            

                5678
            

            

                
            

            

                
    let v5 = InstructionData::Load {

            

        

            

                5679
            

            

                
            

            

                
        opcode: Opcode::Uload16,

            

        

            

                5680
            

            

                
            

            

                
        arg: arg2,

            

        

            

                5681
            

            

                
            

            

                
        flags: arg1,

            

        

            

                5682
            

            

                
            

            

                
        offset: arg3,

            

        

            

                5683
            

            

                
            

            

                
    };

            

        

            

                5684
            

            

                
            

            

                
    let v6 = C::make_inst_ctor(ctx, arg0, &v5);

            

        

            

                5685
            

            

                
            

            

                
    // Rule at /home/smcdev/zk-client-private/near/target/debug/build/cranelift-codegen-c1a82fb675b6a305/out/clif_opt.isle line 523.

            

        

            

                5686
            

            

                
            

            

                
    return v6;

            

        

            

                5687
            

            

                
            

            

                
}

            

        

            

                5688
            

            

                
            

            

                

            

        

            

                5689
            

            

                
            

            

                
// Generated as internal constructor for term sload16.

            

        

            

                5690
            

            

                
            

            

                
pub fn constructor_sload16<C: Context>(

            

        

            

                5691
            

            

                
            

            

                
    ctx: &mut C,

            

        

            

                5692
            

            

                
            

            

                
    arg0: Type,

            

        

            

                5693
            

            

                
            

            

                
    arg1: MemFlags,

            

        

            

                5694
            

            

                
            

            

                
    arg2: Value,

            

        

            

                5695
            

            

                
            

            

                
    arg3: Offset32,

            

        

            

                5696
            

            

                
            

            

                
) -> Value {

            

        

            

                5697
            

            

                
            

            

                
    let v5 = InstructionData::Load {

            

        

            

                5698
            

            

                
            

            

                
        opcode: Opcode::Sload16,

            

        

            

                5699
            

            

                
            

            

                
        arg: arg2,

            

        

            

                5700
            

            

                
            

            

                
        flags: arg1,

            

        

            

                5701
            

            

                
            

            

                
        offset: arg3,

            

        

            

                5702
            

            

                
            

            

                
    };

            

        

            

                5703
            

            

                
            

            

                
    let v6 = C::make_inst_ctor(ctx, arg0, &v5);

            

        

            

                5704
            

            

                
            

            

                
    // Rule at /home/smcdev/zk-client-private/near/target/debug/build/cranelift-codegen-c1a82fb675b6a305/out/clif_opt.isle line 532.

            

        

            

                5705
            

            

                
            

            

                
    return v6;

            

        

            

                5706
            

            

                
            

            

                
}

            

        

            

                5707
            

            

                
            

            

                

            

        

            

                5708
            

            

                
            

            

                
// Generated as internal constructor for term uload32.

            

        

            

                5709
            

            

                
            

            

                
pub fn constructor_uload32<C: Context>(

            

        

            

                5710
            

            

                
            

            

                
    ctx: &mut C,

            

        

            

                5711
            

            

                
            

            

                
    arg0: Type,

            

        

            

                5712
            

            

                
            

            

                
    arg1: MemFlags,

            

        

            

                5713
            

            

                
            

            

                
    arg2: Value,

            

        

            

                5714
            

            

                
            

            

                
    arg3: Offset32,

            

        

            

                5715
            

            

                
            

            

                
) -> Value {

            

        

            

                5716
            

            

                
            

            

                
    let v5 = InstructionData::Load {

            

        

            

                5717
            

            

                
            

            

                
        opcode: Opcode::Uload32,

            

        

            

                5718
            

            

                
            

            

                
        arg: arg2,

            

        

            

                5719
            

            

                
            

            

                
        flags: arg1,

            

        

            

                5720
            

            

                
            

            

                
        offset: arg3,

            

        

            

                5721
            

            

                
            

            

                
    };

            

        

            

                5722
            

            

                
            

            

                
    let v6 = C::make_inst_ctor(ctx, arg0, &v5);

            

        

            

                5723
            

            

                
            

            

                
    // Rule at /home/smcdev/zk-client-private/near/target/debug/build/cranelift-codegen-c1a82fb675b6a305/out/clif_opt.isle line 541.

            

        

            

                5724
            

            

                
            

            

                
    return v6;

            

        

            

                5725
            

            

                
            

            

                
}

            

        

            

                5726
            

            

                
            

            

                

            

        

            

                5727
            

            

                
            

            

                
// Generated as internal constructor for term sload32.

            

        

            

                5728
            

            

                
            

            

                
pub fn constructor_sload32<C: Context>(

            

        

            

                5729
            

            

                
            

            

                
    ctx: &mut C,

            

        

            

                5730
            

            

                
            

            

                
    arg0: Type,

            

        

            

                5731
            

            

                
            

            

                
    arg1: MemFlags,

            

        

            

                5732
            

            

                
            

            

                
    arg2: Value,

            

        

            

                5733
            

            

                
            

            

                
    arg3: Offset32,

            

        

            

                5734
            

            

                
            

            

                
) -> Value {

            

        

            

                5735
            

            

                
            

            

                
    let v5 = InstructionData::Load {

            

        

            

                5736
            

            

                
            

            

                
        opcode: Opcode::Sload32,

            

        

            

                5737
            

            

                
            

            

                
        arg: arg2,

            

        

            

                5738
            

            

                
            

            

                
        flags: arg1,

            

        

            

                5739
            

            

                
            

            

                
        offset: arg3,

            

        

            

                5740
            

            

                
            

            

                
    };

            

        

            

                5741
            

            

                
            

            

                
    let v6 = C::make_inst_ctor(ctx, arg0, &v5);

            

        

            

                5742
            

            

                
            

            

                
    // Rule at /home/smcdev/zk-client-private/near/target/debug/build/cranelift-codegen-c1a82fb675b6a305/out/clif_opt.isle line 550.

            

        

            

                5743
            

            

                
            

            

                
    return v6;

            

        

            

                5744
            

            

                
            

            

                
}

            

        

            

                5745
            

            

                
            

            

                

            

        

            

                5746
            

            

                
            

            

                
// Generated as internal constructor for term uload8x8.

            

        

            

                5747
            

            

                
            

            

                
pub fn constructor_uload8x8<C: Context>(

            

        

            

                5748
            

            

                
            

            

                
    ctx: &mut C,

            

        

            

                5749
            

            

                
            

            

                
    arg0: Type,

            

        

            

                5750
            

            

                
            

            

                
    arg1: MemFlags,

            

        

            

                5751
            

            

                
            

            

                
    arg2: Value,

            

        

            

                5752
            

            

                
            

            

                
    arg3: Offset32,

            

        

            

                5753
            

            

                
            

            

                
) -> Value {

            

        

            

                5754
            

            

                
            

            

                
    let v5 = InstructionData::Load {

            

        

            

                5755
            

            

                
            

            

                
        opcode: Opcode::Uload8x8,

            

        

            

                5756
            

            

                
            

            

                
        arg: arg2,

            

        

            

                5757
            

            

                
            

            

                
        flags: arg1,

            

        

            

                5758
            

            

                
            

            

                
        offset: arg3,

            

        

            

                5759
            

            

                
            

            

                
    };

            

        

            

                5760
            

            

                
            

            

                
    let v6 = C::make_inst_ctor(ctx, arg0, &v5);

            

        

            

                5761
            

            

                
            

            

                
    // Rule at /home/smcdev/zk-client-private/near/target/debug/build/cranelift-codegen-c1a82fb675b6a305/out/clif_opt.isle line 559.

            

        

            

                5762
            

            

                
            

            

                
    return v6;

            

        

            

                5763
            

            

                
            

            

                
}

            

        

            

                5764
            

            

                
            

            

                

            

        

            

                5765
            

            

                
            

            

                
// Generated as internal constructor for term sload8x8.

            

        

            

                5766
            

            

                
            

            

                
pub fn constructor_sload8x8<C: Context>(

            

        

            

                5767
            

            

                
            

            

                
    ctx: &mut C,

            

        

            

                5768
            

            

                
            

            

                
    arg0: Type,

            

        

            

                5769
            

            

                
            

            

                
    arg1: MemFlags,

            

        

            

                5770
            

            

                
            

            

                
    arg2: Value,

            

        

            

                5771
            

            

                
            

            

                
    arg3: Offset32,

            

        

            

                5772
            

            

                
            

            

                
) -> Value {

            

        

            

                5773
            

            

                
            

            

                
    let v5 = InstructionData::Load {

            

        

            

                5774
            

            

                
            

            

                
        opcode: Opcode::Sload8x8,

            

        

            

                5775
            

            

                
            

            

                
        arg: arg2,

            

        

            

                5776
            

            

                
            

            

                
        flags: arg1,

            

        

            

                5777
            

            

                
            

            

                
        offset: arg3,

            

        

            

                5778
            

            

                
            

            

                
    };

            

        

            

                5779
            

            

                
            

            

                
    let v6 = C::make_inst_ctor(ctx, arg0, &v5);

            

        

            

                5780
            

            

                
            

            

                
    // Rule at /home/smcdev/zk-client-private/near/target/debug/build/cranelift-codegen-c1a82fb675b6a305/out/clif_opt.isle line 568.

            

        

            

                5781
            

            

                
            

            

                
    return v6;

            

        

            

                5782
            

            

                
            

            

                
}

            

        

            

                5783
            

            

                
            

            

                

            

        

            

                5784
            

            

                
            

            

                
// Generated as internal constructor for term uload16x4.

            

        

            

                5785
            

            

                
            

            

                
pub fn constructor_uload16x4<C: Context>(

            

        

            

                5786
            

            

                
            

            

                
    ctx: &mut C,

            

        

            

                5787
            

            

                
            

            

                
    arg0: Type,

            

        

            

                5788
            

            

                
            

            

                
    arg1: MemFlags,

            

        

            

                5789
            

            

                
            

            

                
    arg2: Value,

            

        

            

                5790
            

            

                
            

            

                
    arg3: Offset32,

            

        

            

                5791
            

            

                
            

            

                
) -> Value {

            

        

            

                5792
            

            

                
            

            

                
    let v5 = InstructionData::Load {

            

        

            

                5793
            

            

                
            

            

                
        opcode: Opcode::Uload16x4,

            

        

            

                5794
            

            

                
            

            

                
        arg: arg2,

            

        

            

                5795
            

            

                
            

            

                
        flags: arg1,

            

        

            

                5796
            

            

                
            

            

                
        offset: arg3,

            

        

            

                5797
            

            

                
            

            

                
    };

            

        

            

                5798
            

            

                
            

            

                
    let v6 = C::make_inst_ctor(ctx, arg0, &v5);

            

        

            

                5799
            

            

                
            

            

                
    // Rule at /home/smcdev/zk-client-private/near/target/debug/build/cranelift-codegen-c1a82fb675b6a305/out/clif_opt.isle line 577.

            

        

            

                5800
            

            

                
            

            

                
    return v6;

            

        

            

                5801
            

            

                
            

            

                
}

            

        

            

                5802
            

            

                
            

            

                

            

        

            

                5803
            

            

                
            

            

                
// Generated as internal constructor for term sload16x4.

            

        

            

                5804
            

            

                
            

            

                
pub fn constructor_sload16x4<C: Context>(

            

        

            

                5805
            

            

                
            

            

                
    ctx: &mut C,

            

        

            

                5806
            

            

                
            

            

                
    arg0: Type,

            

        

            

                5807
            

            

                
            

            

                
    arg1: MemFlags,

            

        

            

                5808
            

            

                
            

            

                
    arg2: Value,

            

        

            

                5809
            

            

                
            

            

                
    arg3: Offset32,

            

        

            

                5810
            

            

                
            

            

                
) -> Value {

            

        

            

                5811
            

            

                
            

            

                
    let v5 = InstructionData::Load {

            

        

            

                5812
            

            

                
            

            

                
        opcode: Opcode::Sload16x4,

            

        

            

                5813
            

            

                
            

            

                
        arg: arg2,

            

        

            

                5814
            

            

                
            

            

                
        flags: arg1,

            

        

            

                5815
            

            

                
            

            

                
        offset: arg3,

            

        

            

                5816
            

            

                
            

            

                
    };

            

        

            

                5817
            

            

                
            

            

                
    let v6 = C::make_inst_ctor(ctx, arg0, &v5);

            

        

            

                5818
            

            

                
            

            

                
    // Rule at /home/smcdev/zk-client-private/near/target/debug/build/cranelift-codegen-c1a82fb675b6a305/out/clif_opt.isle line 586.

            

        

            

                5819
            

            

                
            

            

                
    return v6;

            

        

            

                5820
            

            

                
            

            

                
}

            

        

            

                5821
            

            

                
            

            

                

            

        

            

                5822
            

            

                
            

            

                
// Generated as internal constructor for term uload32x2.

            

        

            

                5823
            

            

                
            

            

                
pub fn constructor_uload32x2<C: Context>(

            

        

            

                5824
            

            

                
            

            

                
    ctx: &mut C,

            

        

            

                5825
            

            

                
            

            

                
    arg0: Type,

            

        

            

                5826
            

            

                
            

            

                
    arg1: MemFlags,

            

        

            

                5827
            

            

                
            

            

                
    arg2: Value,

            

        

            

                5828
            

            

                
            

            

                
    arg3: Offset32,

            

        

            

                5829
            

            

                
            

            

                
) -> Value {

            

        

            

                5830
            

            

                
            

            

                
    let v5 = InstructionData::Load {

            

        

            

                5831
            

            

                
            

            

                
        opcode: Opcode::Uload32x2,

            

        

            

                5832
            

            

                
            

            

                
        arg: arg2,

            

        

            

                5833
            

            

                
            

            

                
        flags: arg1,

            

        

            

                5834
            

            

                
            

            

                
        offset: arg3,

            

        

            

                5835
            

            

                
            

            

                
    };

            

        

            

                5836
            

            

                
            

            

                
    let v6 = C::make_inst_ctor(ctx, arg0, &v5);

            

        

            

                5837
            

            

                
            

            

                
    // Rule at /home/smcdev/zk-client-private/near/target/debug/build/cranelift-codegen-c1a82fb675b6a305/out/clif_opt.isle line 595.

            

        

            

                5838
            

            

                
            

            

                
    return v6;

            

        

            

                5839
            

            

                
            

            

                
}

            

        

            

                5840
            

            

                
            

            

                

            

        

            

                5841
            

            

                
            

            

                
// Generated as internal constructor for term sload32x2.

            

        

            

                5842
            

            

                
            

            

                
pub fn constructor_sload32x2<C: Context>(

            

        

            

                5843
            

            

                
            

            

                
    ctx: &mut C,

            

        

            

                5844
            

            

                
            

            

                
    arg0: Type,

            

        

            

                5845
            

            

                
            

            

                
    arg1: MemFlags,

            

        

            

                5846
            

            

                
            

            

                
    arg2: Value,

            

        

            

                5847
            

            

                
            

            

                
    arg3: Offset32,

            

        

            

                5848
            

            

                
            

            

                
) -> Value {

            

        

            

                5849
            

            

                
            

            

                
    let v5 = InstructionData::Load {

            

        

            

                5850
            

            

                
            

            

                
        opcode: Opcode::Sload32x2,

            

        

            

                5851
            

            

                
            

            

                
        arg: arg2,

            

        

            

                5852
            

            

                
            

            

                
        flags: arg1,

            

        

            

                5853
            

            

                
            

            

                
        offset: arg3,

            

        

            

                5854
            

            

                
            

            

                
    };

            

        

            

                5855
            

            

                
            

            

                
    let v6 = C::make_inst_ctor(ctx, arg0, &v5);

            

        

            

                5856
            

            

                
            

            

                
    // Rule at /home/smcdev/zk-client-private/near/target/debug/build/cranelift-codegen-c1a82fb675b6a305/out/clif_opt.isle line 604.

            

        

            

                5857
            

            

                
            

            

                
    return v6;

            

        

            

                5858
            

            

                
            

            

                
}

            

        

            

                5859
            

            

                
            

            

                

            

        

            

                5860
            

            

                
            

            

                
// Generated as internal constructor for term stack_load.

            

        

            

                5861
            

            

                
            

            

                
pub fn constructor_stack_load<C: Context>(

            

        

            

                5862
            

            

                
            

            

                
    ctx: &mut C,

            

        

            

                5863
            

            

                
            

            

                
    arg0: Type,

            

        

            

                5864
            

            

                
            

            

                
    arg1: StackSlot,

            

        

            

                5865
            

            

                
            

            

                
    arg2: Offset32,

            

        

            

                5866
            

            

                
            

            

                
) -> Value {

            

        

            

                5867
            

            

                
            

            

                
    let v4 = InstructionData::StackLoad {

            

        

            

                5868
            

            

                
            

            

                
        opcode: Opcode::StackLoad,

            

        

            

                5869
            

            

                
            

            

                
        stack_slot: arg1,

            

        

            

                5870
            

            

                
            

            

                
        offset: arg2,

            

        

            

                5871
            

            

                
            

            

                
    };

            

        

            

                5872
            

            

                
            

            

                
    let v5 = C::make_inst_ctor(ctx, arg0, &v4);

            

        

            

                5873
            

            

                
            

            

                
    // Rule at /home/smcdev/zk-client-private/near/target/debug/build/cranelift-codegen-c1a82fb675b6a305/out/clif_opt.isle line 613.

            

        

            

                5874
            

            

                
            

            

                
    return v5;

            

        

            

                5875
            

            

                
            

            

                
}

            

        

            

                5876
            

            

                
            

            

                

            

        

            

                5877
            

            

                
            

            

                
// Generated as internal constructor for term stack_addr.

            

        

            

                5878
            

            

                
            

            

                
pub fn constructor_stack_addr<C: Context>(

            

        

            

                5879
            

            

                
            

            

                
    ctx: &mut C,

            

        

            

                5880
            

            

                
            

            

                
    arg0: Type,

            

        

            

                5881
            

            

                
            

            

                
    arg1: StackSlot,

            

        

            

                5882
            

            

                
            

            

                
    arg2: Offset32,

            

        

            

                5883
            

            

                
            

            

                
) -> Value {

            

        

            

                5884
            

            

                
            

            

                
    let v4 = InstructionData::StackLoad {

            

        

            

                5885
            

            

                
            

            

                
        opcode: Opcode::StackAddr,

            

        

            

                5886
            

            

                
            

            

                
        stack_slot: arg1,

            

        

            

                5887
            

            

                
            

            

                
        offset: arg2,

            

        

            

                5888
            

            

                
            

            

                
    };

            

        

            

                5889
            

            

                
            

            

                
    let v5 = C::make_inst_ctor(ctx, arg0, &v4);

            

        

            

                5890
            

            

                
            

            

                
    // Rule at /home/smcdev/zk-client-private/near/target/debug/build/cranelift-codegen-c1a82fb675b6a305/out/clif_opt.isle line 622.

            

        

            

                5891
            

            

                
            

            

                
    return v5;

            

        

            

                5892
            

            

                
            

            

                
}

            

        

            

                5893
            

            

                
            

            

                

            

        

            

                5894
            

            

                
            

            

                
// Generated as internal constructor for term dynamic_stack_load.

            

        

            

                5895
            

            

                
            

            

                
pub fn constructor_dynamic_stack_load<C: Context>(

            

        

            

                5896
            

            

                
            

            

                
    ctx: &mut C,

            

        

            

                5897
            

            

                
            

            

                
    arg0: Type,

            

        

            

                5898
            

            

                
            

            

                
    arg1: DynamicStackSlot,

            

        

            

                5899
            

            

                
            

            

                
) -> Value {

            

        

            

                5900
            

            

                
            

            

                
    let v3 = InstructionData::DynamicStackLoad {

            

        

            

                5901
            

            

                
            

            

                
        opcode: Opcode::DynamicStackLoad,

            

        

            

                5902
            

            

                
            

            

                
        dynamic_stack_slot: arg1,

            

        

            

                5903
            

            

                
            

            

                
    };

            

        

            

                5904
            

            

                
            

            

                
    let v4 = C::make_inst_ctor(ctx, arg0, &v3);

            

        

            

                5905
            

            

                
            

            

                
    // Rule at /home/smcdev/zk-client-private/near/target/debug/build/cranelift-codegen-c1a82fb675b6a305/out/clif_opt.isle line 631.

            

        

            

                5906
            

            

                
            

            

                
    return v4;

            

        

            

                5907
            

            

                
            

            

                
}

            

        

            

                5908
            

            

                
            

            

                

            

        

            

                5909
            

            

                
            

            

                
// Generated as internal constructor for term dynamic_stack_addr.

            

        

            

                5910
            

            

                
            

            

                
pub fn constructor_dynamic_stack_addr<C: Context>(

            

        

            

                5911
            

            

                
            

            

                
    ctx: &mut C,

            

        

            

                5912
            

            

                
            

            

                
    arg0: Type,

            

        

            

                5913
            

            

                
            

            

                
    arg1: DynamicStackSlot,

            

        

            

                5914
            

            

                
            

            

                
) -> Value {

            

        

            

                5915
            

            

                
            

            

                
    let v3 = InstructionData::DynamicStackLoad {

            

        

            

                5916
            

            

                
            

            

                
        opcode: Opcode::DynamicStackAddr,

            

        

            

                5917
            

            

                
            

            

                
        dynamic_stack_slot: arg1,

            

        

            

                5918
            

            

                
            

            

                
    };

            

        

            

                5919
            

            

                
            

            

                
    let v4 = C::make_inst_ctor(ctx, arg0, &v3);

            

        

            

                5920
            

            

                
            

            

                
    // Rule at /home/smcdev/zk-client-private/near/target/debug/build/cranelift-codegen-c1a82fb675b6a305/out/clif_opt.isle line 640.

            

        

            

                5921
            

            

                
            

            

                
    return v4;

            

        

            

                5922
            

            

                
            

            

                
}

            

        

            

                5923
            

            

                
            

            

                

            

        

            

                5924
            

            

                
            

            

                
// Generated as internal constructor for term global_value.

            

        

            

                5925
            

            

                
            

            

                
pub fn constructor_global_value<C: Context>(ctx: &mut C, arg0: Type, arg1: GlobalValue) -> Value {

            

        

            

                5926
            

            

                
            

            

                
    let v3 = InstructionData::UnaryGlobalValue {

            

        

            

                5927
            

            

                
            

            

                
        opcode: Opcode::GlobalValue,

            

        

            

                5928
            

            

                
            

            

                
        global_value: arg1,

            

        

            

                5929
            

            

                
            

            

                
    };

            

        

            

                5930
            

            

                
            

            

                
    let v4 = C::make_inst_ctor(ctx, arg0, &v3);

            

        

            

                5931
            

            

                
            

            

                
    // Rule at /home/smcdev/zk-client-private/near/target/debug/build/cranelift-codegen-c1a82fb675b6a305/out/clif_opt.isle line 649.

            

        

            

                5932
            

            

                
            

            

                
    return v4;

            

        

            

                5933
            

            

                
            

            

                
}

            

        

            

                5934
            

            

                
            

            

                

            

        

            

                5935
            

            

                
            

            

                
// Generated as internal constructor for term symbol_value.

            

        

            

                5936
            

            

                
            

            

                
pub fn constructor_symbol_value<C: Context>(ctx: &mut C, arg0: Type, arg1: GlobalValue) -> Value {

            

        

            

                5937
            

            

                
            

            

                
    let v3 = InstructionData::UnaryGlobalValue {

            

        

            

                5938
            

            

                
            

            

                
        opcode: Opcode::SymbolValue,

            

        

            

                5939
            

            

                
            

            

                
        global_value: arg1,

            

        

            

                5940
            

            

                
            

            

                
    };

            

        

            

                5941
            

            

                
            

            

                
    let v4 = C::make_inst_ctor(ctx, arg0, &v3);

            

        

            

                5942
            

            

                
            

            

                
    // Rule at /home/smcdev/zk-client-private/near/target/debug/build/cranelift-codegen-c1a82fb675b6a305/out/clif_opt.isle line 658.

            

        

            

                5943
            

            

                
            

            

                
    return v4;

            

        

            

                5944
            

            

                
            

            

                
}

            

        

            

                5945
            

            

                
            

            

                

            

        

            

                5946
            

            

                
            

            

                
// Generated as internal constructor for term tls_value.

            

        

            

                5947
            

            

                
            

            

                
pub fn constructor_tls_value<C: Context>(ctx: &mut C, arg0: Type, arg1: GlobalValue) -> Value {

            

        

            

                5948
            

            

                
            

            

                
    let v3 = InstructionData::UnaryGlobalValue {

            

        

            

                5949
            

            

                
            

            

                
        opcode: Opcode::TlsValue,

            

        

            

                5950
            

            

                
            

            

                
        global_value: arg1,

            

        

            

                5951
            

            

                
            

            

                
    };

            

        

            

                5952
            

            

                
            

            

                
    let v4 = C::make_inst_ctor(ctx, arg0, &v3);

            

        

            

                5953
            

            

                
            

            

                
    // Rule at /home/smcdev/zk-client-private/near/target/debug/build/cranelift-codegen-c1a82fb675b6a305/out/clif_opt.isle line 667.

            

        

            

                5954
            

            

                
            

            

                
    return v4;

            

        

            

                5955
            

            

                
            

            

                
}

            

        

            

                5956
            

            

                
            

            

                

            

        

            

                5957
            

            

                
            

            

                
// Generated as internal constructor for term get_pinned_reg.

            

        

            

                5958
            

            

                
            

            

                
pub fn constructor_get_pinned_reg<C: Context>(ctx: &mut C, arg0: Type) -> Value {

            

        

            

                5959
            

            

                
            

            

                
    let v2 = InstructionData::NullAry {

            

        

            

                5960
            

            

                
            

            

                
        opcode: Opcode::GetPinnedReg,

            

        

            

                5961
            

            

                
            

            

                
    };

            

        

            

                5962
            

            

                
            

            

                
    let v3 = C::make_inst_ctor(ctx, arg0, &v2);

            

        

            

                5963
            

            

                
            

            

                
    // Rule at /home/smcdev/zk-client-private/near/target/debug/build/cranelift-codegen-c1a82fb675b6a305/out/clif_opt.isle line 676.

            

        

            

                5964
            

            

                
            

            

                
    return v3;

            

        

            

                5965
            

            

                
            

            

                
}

            

        

            

                5966
            

            

                
            

            

                

            

        

            

                5967
            

            

                
            

            

                
// Generated as internal constructor for term get_frame_pointer.

            

        

            

                5968
            

            

                
            

            

                
pub fn constructor_get_frame_pointer<C: Context>(ctx: &mut C, arg0: Type) -> Value {

            

        

            

                5969
            

            

                
            

            

                
    let v2 = InstructionData::NullAry {

            

        

            

                5970
            

            

                
            

            

                
        opcode: Opcode::GetFramePointer,

            

        

            

                5971
            

            

                
            

            

                
    };

            

        

            

                5972
            

            

                
            

            

                
    let v3 = C::make_inst_ctor(ctx, arg0, &v2);

            

        

            

                5973
            

            

                
            

            

                
    // Rule at /home/smcdev/zk-client-private/near/target/debug/build/cranelift-codegen-c1a82fb675b6a305/out/clif_opt.isle line 685.

            

        

            

                5974
            

            

                
            

            

                
    return v3;

            

        

            

                5975
            

            

                
            

            

                
}

            

        

            

                5976
            

            

                
            

            

                

            

        

            

                5977
            

            

                
            

            

                
// Generated as internal constructor for term get_stack_pointer.

            

        

            

                5978
            

            

                
            

            

                
pub fn constructor_get_stack_pointer<C: Context>(ctx: &mut C, arg0: Type) -> Value {

            

        

            

                5979
            

            

                
            

            

                
    let v2 = InstructionData::NullAry {

            

        

            

                5980
            

            

                
            

            

                
        opcode: Opcode::GetStackPointer,

            

        

            

                5981
            

            

                
            

            

                
    };

            

        

            

                5982
            

            

                
            

            

                
    let v3 = C::make_inst_ctor(ctx, arg0, &v2);

            

        

            

                5983
            

            

                
            

            

                
    // Rule at /home/smcdev/zk-client-private/near/target/debug/build/cranelift-codegen-c1a82fb675b6a305/out/clif_opt.isle line 694.

            

        

            

                5984
            

            

                
            

            

                
    return v3;

            

        

            

                5985
            

            

                
            

            

                
}

            

        

            

                5986
            

            

                
            

            

                

            

        

            

                5987
            

            

                
            

            

                
// Generated as internal constructor for term get_return_address.

            

        

            

                5988
            

            

                
            

            

                
pub fn constructor_get_return_address<C: Context>(ctx: &mut C, arg0: Type) -> Value {

            

        

            

                5989
            

            

                
            

            

                
    let v2 = InstructionData::NullAry {

            

        

            

                5990
            

            

                
            

            

                
        opcode: Opcode::GetReturnAddress,

            

        

            

                5991
            

            

                
            

            

                
    };

            

        

            

                5992
            

            

                
            

            

                
    let v3 = C::make_inst_ctor(ctx, arg0, &v2);

            

        

            

                5993
            

            

                
            

            

                
    // Rule at /home/smcdev/zk-client-private/near/target/debug/build/cranelift-codegen-c1a82fb675b6a305/out/clif_opt.isle line 703.

            

        

            

                5994
            

            

                
            

            

                
    return v3;

            

        

            

                5995
            

            

                
            

            

                
}

            

        

            

                5996
            

            

                
            

            

                

            

        

            

                5997
            

            

                
            

            

                
// Generated as internal constructor for term table_addr.

            

        

            

                5998
            

            

                
            

            

                
pub fn constructor_table_addr<C: Context>(

            

        

            

                5999
            

            

                
            

            

                
    ctx: &mut C,

            

        

            

                6000
            

            

                
            

            

                
    arg0: Type,

            

        

            

                6001
            

            

                
            

            

                
    arg1: Table,

            

        

            

                6002
            

            

                
            

            

                
    arg2: Value,

            

        

            

                6003
            

            

                
            

            

                
    arg3: Offset32,

            

        

            

                6004
            

            

                
            

            

                
) -> Value {

            

        

            

                6005
            

            

                
            

            

                
    let v5 = InstructionData::TableAddr {

            

        

            

                6006
            

            

                
            

            

                
        opcode: Opcode::TableAddr,

            

        

            

                6007
            

            

                
            

            

                
        arg: arg2,

            

        

            

                6008
            

            

                
            

            

                
        table: arg1,

            

        

            

                6009
            

            

                
            

            

                
        offset: arg3,

            

        

            

                6010
            

            

                
            

            

                
    };

            

        

            

                6011
            

            

                
            

            

                
    let v6 = C::make_inst_ctor(ctx, arg0, &v5);

            

        

            

                6012
            

            

                
            

            

                
    // Rule at /home/smcdev/zk-client-private/near/target/debug/build/cranelift-codegen-c1a82fb675b6a305/out/clif_opt.isle line 712.

            

        

            

                6013
            

            

                
            

            

                
    return v6;

            

        

            

                6014
            

            

                
            

            

                
}

            

        

            

                6015
            

            

                
            

            

                

            

        

            

                6016
            

            

                
            

            

                
// Generated as internal constructor for term iconst.

            

        

            

                6017
            

            

                
            

            

                
pub fn constructor_iconst<C: Context>(ctx: &mut C, arg0: Type, arg1: Imm64) -> Value {

            

        

            

                6018
            

            

                
            

            

                
    let v3 = InstructionData::UnaryImm {

            

        

            

                6019
            

            

                
            

            

                
        opcode: Opcode::Iconst,

            

        

            

                6020
            

            

                
            

            

                
        imm: arg1,

            

        

            

                6021
            

            

                
            

            

                
    };

            

        

            

                6022
            

            

                
            

            

                
    let v4 = C::make_inst_ctor(ctx, arg0, &v3);

            

        

            

                6023
            

            

                
            

            

                
    // Rule at /home/smcdev/zk-client-private/near/target/debug/build/cranelift-codegen-c1a82fb675b6a305/out/clif_opt.isle line 721.

            

        

            

                6024
            

            

                
            

            

                
    return v4;

            

        

            

                6025
            

            

                
            

            

                
}

            

        

            

                6026
            

            

                
            

            

                

            

        

            

                6027
            

            

                
            

            

                
// Generated as internal constructor for term f32const.

            

        

            

                6028
            

            

                
            

            

                
pub fn constructor_f32const<C: Context>(ctx: &mut C, arg0: Type, arg1: Ieee32) -> Value {

            

        

            

                6029
            

            

                
            

            

                
    let v3 = InstructionData::UnaryIeee32 {

            

        

            

                6030
            

            

                
            

            

                
        opcode: Opcode::F32const,

            

        

            

                6031
            

            

                
            

            

                
        imm: arg1,

            

        

            

                6032
            

            

                
            

            

                
    };

            

        

            

                6033
            

            

                
            

            

                
    let v4 = C::make_inst_ctor(ctx, arg0, &v3);

            

        

            

                6034
            

            

                
            

            

                
    // Rule at /home/smcdev/zk-client-private/near/target/debug/build/cranelift-codegen-c1a82fb675b6a305/out/clif_opt.isle line 730.

            

        

            

                6035
            

            

                
            

            

                
    return v4;

            

        

            

                6036
            

            

                
            

            

                
}

            

        

            

                6037
            

            

                
            

            

                

            

        

            

                6038
            

            

                
            

            

                
// Generated as internal constructor for term f64const.

            

        

            

                6039
            

            

                
            

            

                
pub fn constructor_f64const<C: Context>(ctx: &mut C, arg0: Type, arg1: Ieee64) -> Value {

            

        

            

                6040
            

            

                
            

            

                
    let v3 = InstructionData::UnaryIeee64 {

            

        

            

                6041
            

            

                
            

            

                
        opcode: Opcode::F64const,

            

        

            

                6042
            

            

                
            

            

                
        imm: arg1,

            

        

            

                6043
            

            

                
            

            

                
    };

            

        

            

                6044
            

            

                
            

            

                
    let v4 = C::make_inst_ctor(ctx, arg0, &v3);

            

        

            

                6045
            

            

                
            

            

                
    // Rule at /home/smcdev/zk-client-private/near/target/debug/build/cranelift-codegen-c1a82fb675b6a305/out/clif_opt.isle line 739.

            

        

            

                6046
            

            

                
            

            

                
    return v4;

            

        

            

                6047
            

            

                
            

            

                
}

            

        

            

                6048
            

            

                
            

            

                

            

        

            

                6049
            

            

                
            

            

                
// Generated as internal constructor for term vconst.

            

        

            

                6050
            

            

                
            

            

                
pub fn constructor_vconst<C: Context>(ctx: &mut C, arg0: Type, arg1: Constant) -> Value {

            

        

            

                6051
            

            

                
            

            

                
    let v3 = InstructionData::UnaryConst {

            

        

            

                6052
            

            

                
            

            

                
        opcode: Opcode::Vconst,

            

        

            

                6053
            

            

                
            

            

                
        constant_handle: arg1,

            

        

            

                6054
            

            

                
            

            

                
    };

            

        

            

                6055
            

            

                
            

            

                
    let v4 = C::make_inst_ctor(ctx, arg0, &v3);

            

        

            

                6056
            

            

                
            

            

                
    // Rule at /home/smcdev/zk-client-private/near/target/debug/build/cranelift-codegen-c1a82fb675b6a305/out/clif_opt.isle line 748.

            

        

            

                6057
            

            

                
            

            

                
    return v4;

            

        

            

                6058
            

            

                
            

            

                
}

            

        

            

                6059
            

            

                
            

            

                

            

        

            

                6060
            

            

                
            

            

                
// Generated as internal constructor for term shuffle.

            

        

            

                6061
            

            

                
            

            

                
pub fn constructor_shuffle<C: Context>(

            

        

            

                6062
            

            

                
            

            

                
    ctx: &mut C,

            

        

            

                6063
            

            

                
            

            

                
    arg0: Type,

            

        

            

                6064
            

            

                
            

            

                
    arg1: Value,

            

        

            

                6065
            

            

                
            

            

                
    arg2: Value,

            

        

            

                6066
            

            

                
            

            

                
    arg3: Immediate,

            

        

            

                6067
            

            

                
            

            

                
) -> Value {

            

        

            

                6068
            

            

                
            

            

                
    let v5 = &C::value_array_2_ctor(ctx, arg1, arg2);

            

        

            

                6069
            

            

                
            

            

                
    let v6 = InstructionData::Shuffle {

            

        

            

                6070
            

            

                
            

            

                
        opcode: Opcode::Shuffle,

            

        

            

                6071
            

            

                
            

            

                
        args: v5.clone(),

            

        

            

                6072
            

            

                
            

            

                
        imm: arg3,

            

        

            

                6073
            

            

                
            

            

                
    };

            

        

            

                6074
            

            

                
            

            

                
    let v7 = C::make_inst_ctor(ctx, arg0, &v6);

            

        

            

                6075
            

            

                
            

            

                
    // Rule at /home/smcdev/zk-client-private/near/target/debug/build/cranelift-codegen-c1a82fb675b6a305/out/clif_opt.isle line 757.

            

        

            

                6076
            

            

                
            

            

                
    return v7;

            

        

            

                6077
            

            

                
            

            

                
}

            

        

            

                6078
            

            

                
            

            

                

            

        

            

                6079
            

            

                
            

            

                
// Generated as internal constructor for term null.

            

        

            

                6080
            

            

                
            

            

                
pub fn constructor_null<C: Context>(ctx: &mut C, arg0: Type) -> Value {

            

        

            

                6081
            

            

                
            

            

                
    let v2 = InstructionData::NullAry {

            

        

            

                6082
            

            

                
            

            

                
        opcode: Opcode::Null,

            

        

            

                6083
            

            

                
            

            

                
    };

            

        

            

                6084
            

            

                
            

            

                
    let v3 = C::make_inst_ctor(ctx, arg0, &v2);

            

        

            

                6085
            

            

                
            

            

                
    // Rule at /home/smcdev/zk-client-private/near/target/debug/build/cranelift-codegen-c1a82fb675b6a305/out/clif_opt.isle line 766.

            

        

            

                6086
            

            

                
            

            

                
    return v3;

            

        

            

                6087
            

            

                
            

            

                
}

            

        

            

                6088
            

            

                
            

            

                

            

        

            

                6089
            

            

                
            

            

                
// Generated as internal constructor for term select.

            

        

            

                6090
            

            

                
            

            

                
pub fn constructor_select<C: Context>(

            

        

            

                6091
            

            

                
            

            

                
    ctx: &mut C,

            

        

            

                6092
            

            

                
            

            

                
    arg0: Type,

            

        

            

                6093
            

            

                
            

            

                
    arg1: Value,

            

        

            

                6094
            

            

                
            

            

                
    arg2: Value,

            

        

            

                6095
            

            

                
            

            

                
    arg3: Value,

            

        

            

                6096
            

            

                
            

            

                
) -> Value {

            

        

            

                6097
            

            

                
            

            

                
    let v5 = &C::value_array_3_ctor(ctx, arg1, arg2, arg3);

            

        

            

                6098
            

            

                
            

            

                
    let v6 = InstructionData::Ternary {

            

        

            

                6099
            

            

                
            

            

                
        opcode: Opcode::Select,

            

        

            

                6100
            

            

                
            

            

                
        args: v5.clone(),

            

        

            

                6101
            

            

                
            

            

                
    };

            

        

            

                6102
            

            

                
            

            

                
    let v7 = C::make_inst_ctor(ctx, arg0, &v6);

            

        

            

                6103
            

            

                
            

            

                
    // Rule at /home/smcdev/zk-client-private/near/target/debug/build/cranelift-codegen-c1a82fb675b6a305/out/clif_opt.isle line 775.

            

        

            

                6104
            

            

                
            

            

                
    return v7;

            

        

            

                6105
            

            

                
            

            

                
}

            

        

            

                6106
            

            

                
            

            

                

            

        

            

                6107
            

            

                
            

            

                
// Generated as internal constructor for term select_spectre_guard.

            

        

            

                6108
            

            

                
            

            

                
pub fn constructor_select_spectre_guard<C: Context>(

            

        

            

                6109
            

            

                
            

            

                
    ctx: &mut C,

            

        

            

                6110
            

            

                
            

            

                
    arg0: Type,

            

        

            

                6111
            

            

                
            

            

                
    arg1: Value,

            

        

            

                6112
            

            

                
            

            

                
    arg2: Value,

            

        

            

                6113
            

            

                
            

            

                
    arg3: Value,

            

        

            

                6114
            

            

                
            

            

                
) -> Value {

            

        

            

                6115
            

            

                
            

            

                
    let v5 = &C::value_array_3_ctor(ctx, arg1, arg2, arg3);

            

        

            

                6116
            

            

                
            

            

                
    let v6 = InstructionData::Ternary {

            

        

            

                6117
            

            

                
            

            

                
        opcode: Opcode::SelectSpectreGuard,

            

        

            

                6118
            

            

                
            

            

                
        args: v5.clone(),

            

        

            

                6119
            

            

                
            

            

                
    };

            

        

            

                6120
            

            

                
            

            

                
    let v7 = C::make_inst_ctor(ctx, arg0, &v6);

            

        

            

                6121
            

            

                
            

            

                
    // Rule at /home/smcdev/zk-client-private/near/target/debug/build/cranelift-codegen-c1a82fb675b6a305/out/clif_opt.isle line 784.

            

        

            

                6122
            

            

                
            

            

                
    return v7;

            

        

            

                6123
            

            

                
            

            

                
}

            

        

            

                6124
            

            

                
            

            

                

            

        

            

                6125
            

            

                
            

            

                
// Generated as internal constructor for term bitselect.

            

        

            

                6126
            

            

                
            

            

                
pub fn constructor_bitselect<C: Context>(

            

        

            

                6127
            

            

                
            

            

                
    ctx: &mut C,

            

        

            

                6128
            

            

                
            

            

                
    arg0: Type,

            

        

            

                6129
            

            

                
            

            

                
    arg1: Value,

            

        

            

                6130
            

            

                
            

            

                
    arg2: Value,

            

        

            

                6131
            

            

                
            

            

                
    arg3: Value,

            

        

            

                6132
            

            

                
            

            

                
) -> Value {

            

        

            

                6133
            

            

                
            

            

                
    let v5 = &C::value_array_3_ctor(ctx, arg1, arg2, arg3);

            

        

            

                6134
            

            

                
            

            

                
    let v6 = InstructionData::Ternary {

            

        

            

                6135
            

            

                
            

            

                
        opcode: Opcode::Bitselect,

            

        

            

                6136
            

            

                
            

            

                
        args: v5.clone(),

            

        

            

                6137
            

            

                
            

            

                
    };

            

        

            

                6138
            

            

                
            

            

                
    let v7 = C::make_inst_ctor(ctx, arg0, &v6);

            

        

            

                6139
            

            

                
            

            

                
    // Rule at /home/smcdev/zk-client-private/near/target/debug/build/cranelift-codegen-c1a82fb675b6a305/out/clif_opt.isle line 793.

            

        

            

                6140
            

            

                
            

            

                
    return v7;

            

        

            

                6141
            

            

                
            

            

                
}

            

        

            

                6142
            

            

                
            

            

                

            

        

            

                6143
            

            

                
            

            

                
// Generated as internal constructor for term x86_blendv.

            

        

            

                6144
            

            

                
            

            

                
pub fn constructor_x86_blendv<C: Context>(

            

        

            

                6145
            

            

                
            

            

                
    ctx: &mut C,

            

        

            

                6146
            

            

                
            

            

                
    arg0: Type,

            

        

            

                6147
            

            

                
            

            

                
    arg1: Value,

            

        

            

                6148
            

            

                
            

            

                
    arg2: Value,

            

        

            

                6149
            

            

                
            

            

                
    arg3: Value,

            

        

            

                6150
            

            

                
            

            

                
) -> Value {

            

        

            

                6151
            

            

                
            

            

                
    let v5 = &C::value_array_3_ctor(ctx, arg1, arg2, arg3);

            

        

            

                6152
            

            

                
            

            

                
    let v6 = InstructionData::Ternary {

            

        

            

                6153
            

            

                
            

            

                
        opcode: Opcode::X86Blendv,

            

        

            

                6154
            

            

                
            

            

                
        args: v5.clone(),

            

        

            

                6155
            

            

                
            

            

                
    };

            

        

            

                6156
            

            

                
            

            

                
    let v7 = C::make_inst_ctor(ctx, arg0, &v6);

            

        

            

                6157
            

            

                
            

            

                
    // Rule at /home/smcdev/zk-client-private/near/target/debug/build/cranelift-codegen-c1a82fb675b6a305/out/clif_opt.isle line 802.

            

        

            

                6158
            

            

                
            

            

                
    return v7;

            

        

            

                6159
            

            

                
            

            

                
}

            

        

            

                6160
            

            

                
            

            

                

            

        

            

                6161
            

            

                
            

            

                
// Generated as internal constructor for term vany_true.

            

        

            

                6162
            

            

                
            

            

                
pub fn constructor_vany_true<C: Context>(ctx: &mut C, arg0: Type, arg1: Value) -> Value {

            

        

            

                6163
            

            

                
            

            

                
    let v3 = InstructionData::Unary {

            

        

            

                6164
            

            

                
            

            

                
        opcode: Opcode::VanyTrue,

            

        

            

                6165
            

            

                
            

            

                
        arg: arg1,

            

        

            

                6166
            

            

                
            

            

                
    };

            

        

            

                6167
            

            

                
            

            

                
    let v4 = C::make_inst_ctor(ctx, arg0, &v3);

            

        

            

                6168
            

            

                
            

            

                
    // Rule at /home/smcdev/zk-client-private/near/target/debug/build/cranelift-codegen-c1a82fb675b6a305/out/clif_opt.isle line 811.

            

        

            

                6169
            

            

                
            

            

                
    return v4;

            

        

            

                6170
            

            

                
            

            

                
}

            

        

            

                6171
            

            

                
            

            

                

            

        

            

                6172
            

            

                
            

            

                
// Generated as internal constructor for term vall_true.

            

        

            

                6173
            

            

                
            

            

                
pub fn constructor_vall_true<C: Context>(ctx: &mut C, arg0: Type, arg1: Value) -> Value {

            

        

            

                6174
            

            

                
            

            

                
    let v3 = InstructionData::Unary {

            

        

            

                6175
            

            

                
            

            

                
        opcode: Opcode::VallTrue,

            

        

            

                6176
            

            

                
            

            

                
        arg: arg1,

            

        

            

                6177
            

            

                
            

            

                
    };

            

        

            

                6178
            

            

                
            

            

                
    let v4 = C::make_inst_ctor(ctx, arg0, &v3);

            

        

            

                6179
            

            

                
            

            

                
    // Rule at /home/smcdev/zk-client-private/near/target/debug/build/cranelift-codegen-c1a82fb675b6a305/out/clif_opt.isle line 820.

            

        

            

                6180
            

            

                
            

            

                
    return v4;

            

        

            

                6181
            

            

                
            

            

                
}

            

        

            

                6182
            

            

                
            

            

                

            

        

            

                6183
            

            

                
            

            

                
// Generated as internal constructor for term vhigh_bits.

            

        

            

                6184
            

            

                
            

            

                
pub fn constructor_vhigh_bits<C: Context>(ctx: &mut C, arg0: Type, arg1: Value) -> Value {

            

        

            

                6185
            

            

                
            

            

                
    let v3 = InstructionData::Unary {

            

        

            

                6186
            

            

                
            

            

                
        opcode: Opcode::VhighBits,

            

        

            

                6187
            

            

                
            

            

                
        arg: arg1,

            

        

            

                6188
            

            

                
            

            

                
    };

            

        

            

                6189
            

            

                
            

            

                
    let v4 = C::make_inst_ctor(ctx, arg0, &v3);

            

        

            

                6190
            

            

                
            

            

                
    // Rule at /home/smcdev/zk-client-private/near/target/debug/build/cranelift-codegen-c1a82fb675b6a305/out/clif_opt.isle line 829.

            

        

            

                6191
            

            

                
            

            

                
    return v4;

            

        

            

                6192
            

            

                
            

            

                
}

            

        

            

                6193
            

            

                
            

            

                

            

        

            

                6194
            

            

                
            

            

                
// Generated as internal constructor for term icmp.

            

        

            

                6195
            

            

                
            

            

                
pub fn constructor_icmp<C: Context>(

            

        

            

                6196
            

            

                
            

            

                
    ctx: &mut C,

            

        

            

                6197
            

            

                
            

            

                
    arg0: Type,

            

        

            

                6198
            

            

                
            

            

                
    arg1: &IntCC,

            

        

            

                6199
            

            

                
            

            

                
    arg2: Value,

            

        

            

                6200
            

            

                
            

            

                
    arg3: Value,

            

        

            

                6201
            

            

                
            

            

                
) -> Value {

            

        

            

                6202
            

            

                
            

            

                
    let v5 = &C::value_array_2_ctor(ctx, arg2, arg3);

            

        

            

                6203
            

            

                
            

            

                
    let v6 = InstructionData::IntCompare {

            

        

            

                6204
            

            

                
            

            

                
        opcode: Opcode::Icmp,

            

        

            

                6205
            

            

                
            

            

                
        args: v5.clone(),

            

        

            

                6206
            

            

                
            

            

                
        cond: arg1.clone(),

            

        

            

                6207
            

            

                
            

            

                
    };

            

        

            

                6208
            

            

                
            

            

                
    let v7 = C::make_inst_ctor(ctx, arg0, &v6);

            

        

            

                6209
            

            

                
            

            

                
    // Rule at /home/smcdev/zk-client-private/near/target/debug/build/cranelift-codegen-c1a82fb675b6a305/out/clif_opt.isle line 838.

            

        

            

                6210
            

            

                
            

            

                
    return v7;

            

        

            

                6211
            

            

                
            

            

                
}

            

        

            

                6212
            

            

                
            

            

                

            

        

            

                6213
            

            

                
            

            

                
// Generated as internal constructor for term icmp_imm.

            

        

            

                6214
            

            

                
            

            

                
pub fn constructor_icmp_imm<C: Context>(

            

        

            

                6215
            

            

                
            

            

                
    ctx: &mut C,

            

        

            

                6216
            

            

                
            

            

                
    arg0: Type,

            

        

            

                6217
            

            

                
            

            

                
    arg1: &IntCC,

            

        

            

                6218
            

            

                
            

            

                
    arg2: Value,

            

        

            

                6219
            

            

                
            

            

                
    arg3: Imm64,

            

        

            

                6220
            

            

                
            

            

                
) -> Value {

            

        

            

                6221
            

            

                
            

            

                
    let v5 = InstructionData::IntCompareImm {

            

        

            

                6222
            

            

                
            

            

                
        opcode: Opcode::IcmpImm,

            

        

            

                6223
            

            

                
            

            

                
        arg: arg2,

            

        

            

                6224
            

            

                
            

            

                
        cond: arg1.clone(),

            

        

            

                6225
            

            

                
            

            

                
        imm: arg3,

            

        

            

                6226
            

            

                
            

            

                
    };

            

        

            

                6227
            

            

                
            

            

                
    let v6 = C::make_inst_ctor(ctx, arg0, &v5);

            

        

            

                6228
            

            

                
            

            

                
    // Rule at /home/smcdev/zk-client-private/near/target/debug/build/cranelift-codegen-c1a82fb675b6a305/out/clif_opt.isle line 847.

            

        

            

                6229
            

            

                
            

            

                
    return v6;

            

        

            

                6230
            

            

                
            

            

                
}

            

        

            

                6231
            

            

                
            

            

                

            

        

            

                6232
            

            

                
            

            

                
// Generated as internal constructor for term iadd.

            

        

            

                6233
            

            

                
            

            

                
pub fn constructor_iadd<C: Context>(ctx: &mut C, arg0: Type, arg1: Value, arg2: Value) -> Value {

            

        

            

                6234
            

            

                
            

            

                
    let v4 = &C::value_array_2_ctor(ctx, arg1, arg2);

            

        

            

                6235
            

            

                
            

            

                
    let v5 = InstructionData::Binary {

            

        

            

                6236
            

            

                
            

            

                
        opcode: Opcode::Iadd,

            

        

            

                6237
            

            

                
            

            

                
        args: v4.clone(),

            

        

            

                6238
            

            

                
            

            

                
    };

            

        

            

                6239
            

            

                
            

            

                
    let v6 = C::make_inst_ctor(ctx, arg0, &v5);

            

        

            

                6240
            

            

                
            

            

                
    // Rule at /home/smcdev/zk-client-private/near/target/debug/build/cranelift-codegen-c1a82fb675b6a305/out/clif_opt.isle line 856.

            

        

            

                6241
            

            

                
            

            

                
    return v6;

            

        

            

                6242
            

            

                
            

            

                
}

            

        

            

                6243
            

            

                
            

            

                

            

        

            

                6244
            

            

                
            

            

                
// Generated as internal constructor for term isub.

            

        

            

                6245
            

            

                
            

            

                
pub fn constructor_isub<C: Context>(ctx: &mut C, arg0: Type, arg1: Value, arg2: Value) -> Value {

            

        

            

                6246
            

            

                
            

            

                
    let v4 = &C::value_array_2_ctor(ctx, arg1, arg2);

            

        

            

                6247
            

            

                
            

            

                
    let v5 = InstructionData::Binary {

            

        

            

                6248
            

            

                
            

            

                
        opcode: Opcode::Isub,

            

        

            

                6249
            

            

                
            

            

                
        args: v4.clone(),

            

        

            

                6250
            

            

                
            

            

                
    };

            

        

            

                6251
            

            

                
            

            

                
    let v6 = C::make_inst_ctor(ctx, arg0, &v5);

            

        

            

                6252
            

            

                
            

            

                
    // Rule at /home/smcdev/zk-client-private/near/target/debug/build/cranelift-codegen-c1a82fb675b6a305/out/clif_opt.isle line 865.

            

        

            

                6253
            

            

                
            

            

                
    return v6;

            

        

            

                6254
            

            

                
            

            

                
}

            

        

            

                6255
            

            

                
            

            

                

            

        

            

                6256
            

            

                
            

            

                
// Generated as internal constructor for term ineg.

            

        

            

                6257
            

            

                
            

            

                
pub fn constructor_ineg<C: Context>(ctx: &mut C, arg0: Type, arg1: Value) -> Value {

            

        

            

                6258
            

            

                
            

            

                
    let v3 = InstructionData::Unary {

            

        

            

                6259
            

            

                
            

            

                
        opcode: Opcode::Ineg,

            

        

            

                6260
            

            

                
            

            

                
        arg: arg1,

            

        

            

                6261
            

            

                
            

            

                
    };

            

        

            

                6262
            

            

                
            

            

                
    let v4 = C::make_inst_ctor(ctx, arg0, &v3);

            

        

            

                6263
            

            

                
            

            

                
    // Rule at /home/smcdev/zk-client-private/near/target/debug/build/cranelift-codegen-c1a82fb675b6a305/out/clif_opt.isle line 874.

            

        

            

                6264
            

            

                
            

            

                
    return v4;

            

        

            

                6265
            

            

                
            

            

                
}

            

        

            

                6266
            

            

                
            

            

                

            

        

            

                6267
            

            

                
            

            

                
// Generated as internal constructor for term iabs.

            

        

            

                6268
            

            

                
            

            

                
pub fn constructor_iabs<C: Context>(ctx: &mut C, arg0: Type, arg1: Value) -> Value {

            

        

            

                6269
            

            

                
            

            

                
    let v3 = InstructionData::Unary {

            

        

            

                6270
            

            

                
            

            

                
        opcode: Opcode::Iabs,

            

        

            

                6271
            

            

                
            

            

                
        arg: arg1,

            

        

            

                6272
            

            

                
            

            

                
    };

            

        

            

                6273
            

            

                
            

            

                
    let v4 = C::make_inst_ctor(ctx, arg0, &v3);

            

        

            

                6274
            

            

                
            

            

                
    // Rule at /home/smcdev/zk-client-private/near/target/debug/build/cranelift-codegen-c1a82fb675b6a305/out/clif_opt.isle line 883.

            

        

            

                6275
            

            

                
            

            

                
    return v4;

            

        

            

                6276
            

            

                
            

            

                
}

            

        

            

                6277
            

            

                
            

            

                

            

        

            

                6278
            

            

                
            

            

                
// Generated as internal constructor for term imul.

            

        

            

                6279
            

            

                
            

            

                
pub fn constructor_imul<C: Context>(ctx: &mut C, arg0: Type, arg1: Value, arg2: Value) -> Value {

            

        

            

                6280
            

            

                
            

            

                
    let v4 = &C::value_array_2_ctor(ctx, arg1, arg2);

            

        

            

                6281
            

            

                
            

            

                
    let v5 = InstructionData::Binary {

            

        

            

                6282
            

            

                
            

            

                
        opcode: Opcode::Imul,

            

        

            

                6283
            

            

                
            

            

                
        args: v4.clone(),

            

        

            

                6284
            

            

                
            

            

                
    };

            

        

            

                6285
            

            

                
            

            

                
    let v6 = C::make_inst_ctor(ctx, arg0, &v5);

            

        

            

                6286
            

            

                
            

            

                
    // Rule at /home/smcdev/zk-client-private/near/target/debug/build/cranelift-codegen-c1a82fb675b6a305/out/clif_opt.isle line 892.

            

        

            

                6287
            

            

                
            

            

                
    return v6;

            

        

            

                6288
            

            

                
            

            

                
}

            

        

            

                6289
            

            

                
            

            

                

            

        

            

                6290
            

            

                
            

            

                
// Generated as internal constructor for term umulhi.

            

        

            

                6291
            

            

                
            

            

                
pub fn constructor_umulhi<C: Context>(ctx: &mut C, arg0: Type, arg1: Value, arg2: Value) -> Value {

            

        

            

                6292
            

            

                
            

            

                
    let v4 = &C::value_array_2_ctor(ctx, arg1, arg2);

            

        

            

                6293
            

            

                
            

            

                
    let v5 = InstructionData::Binary {

            

        

            

                6294
            

            

                
            

            

                
        opcode: Opcode::Umulhi,

            

        

            

                6295
            

            

                
            

            

                
        args: v4.clone(),

            

        

            

                6296
            

            

                
            

            

                
    };

            

        

            

                6297
            

            

                
            

            

                
    let v6 = C::make_inst_ctor(ctx, arg0, &v5);

            

        

            

                6298
            

            

                
            

            

                
    // Rule at /home/smcdev/zk-client-private/near/target/debug/build/cranelift-codegen-c1a82fb675b6a305/out/clif_opt.isle line 901.

            

        

            

                6299
            

            

                
            

            

                
    return v6;

            

        

            

                6300
            

            

                
            

            

                
}

            

        

            

                6301
            

            

                
            

            

                

            

        

            

                6302
            

            

                
            

            

                
// Generated as internal constructor for term smulhi.

            

        

            

                6303
            

            

                
            

            

                
pub fn constructor_smulhi<C: Context>(ctx: &mut C, arg0: Type, arg1: Value, arg2: Value) -> Value {

            

        

            

                6304
            

            

                
            

            

                
    let v4 = &C::value_array_2_ctor(ctx, arg1, arg2);

            

        

            

                6305
            

            

                
            

            

                
    let v5 = InstructionData::Binary {

            

        

            

                6306
            

            

                
            

            

                
        opcode: Opcode::Smulhi,

            

        

            

                6307
            

            

                
            

            

                
        args: v4.clone(),

            

        

            

                6308
            

            

                
            

            

                
    };

            

        

            

                6309
            

            

                
            

            

                
    let v6 = C::make_inst_ctor(ctx, arg0, &v5);

            

        

            

                6310
            

            

                
            

            

                
    // Rule at /home/smcdev/zk-client-private/near/target/debug/build/cranelift-codegen-c1a82fb675b6a305/out/clif_opt.isle line 910.

            

        

            

                6311
            

            

                
            

            

                
    return v6;

            

        

            

                6312
            

            

                
            

            

                
}

            

        

            

                6313
            

            

                
            

            

                

            

        

            

                6314
            

            

                
            

            

                
// Generated as internal constructor for term sqmul_round_sat.

            

        

            

                6315
            

            

                
            

            

                
pub fn constructor_sqmul_round_sat<C: Context>(

            

        

            

                6316
            

            

                
            

            

                
    ctx: &mut C,

            

        

            

                6317
            

            

                
            

            

                
    arg0: Type,

            

        

            

                6318
            

            

                
            

            

                
    arg1: Value,

            

        

            

                6319
            

            

                
            

            

                
    arg2: Value,

            

        

            

                6320
            

            

                
            

            

                
) -> Value {

            

        

            

                6321
            

            

                
            

            

                
    let v4 = &C::value_array_2_ctor(ctx, arg1, arg2);

            

        

            

                6322
            

            

                
            

            

                
    let v5 = InstructionData::Binary {

            

        

            

                6323
            

            

                
            

            

                
        opcode: Opcode::SqmulRoundSat,

            

        

            

                6324
            

            

                
            

            

                
        args: v4.clone(),

            

        

            

                6325
            

            

                
            

            

                
    };

            

        

            

                6326
            

            

                
            

            

                
    let v6 = C::make_inst_ctor(ctx, arg0, &v5);

            

        

            

                6327
            

            

                
            

            

                
    // Rule at /home/smcdev/zk-client-private/near/target/debug/build/cranelift-codegen-c1a82fb675b6a305/out/clif_opt.isle line 919.

            

        

            

                6328
            

            

                
            

            

                
    return v6;

            

        

            

                6329
            

            

                
            

            

                
}

            

        

            

                6330
            

            

                
            

            

                

            

        

            

                6331
            

            

                
            

            

                
// Generated as internal constructor for term x86_pmulhrsw.

            

        

            

                6332
            

            

                
            

            

                
pub fn constructor_x86_pmulhrsw<C: Context>(

            

        

            

                6333
            

            

                
            

            

                
    ctx: &mut C,

            

        

            

                6334
            

            

                
            

            

                
    arg0: Type,

            

        

            

                6335
            

            

                
            

            

                
    arg1: Value,

            

        

            

                6336
            

            

                
            

            

                
    arg2: Value,

            

        

            

                6337
            

            

                
            

            

                
) -> Value {

            

        

            

                6338
            

            

                
            

            

                
    let v4 = &C::value_array_2_ctor(ctx, arg1, arg2);

            

        

            

                6339
            

            

                
            

            

                
    let v5 = InstructionData::Binary {

            

        

            

                6340
            

            

                
            

            

                
        opcode: Opcode::X86Pmulhrsw,

            

        

            

                6341
            

            

                
            

            

                
        args: v4.clone(),

            

        

            

                6342
            

            

                
            

            

                
    };

            

        

            

                6343
            

            

                
            

            

                
    let v6 = C::make_inst_ctor(ctx, arg0, &v5);

            

        

            

                6344
            

            

                
            

            

                
    // Rule at /home/smcdev/zk-client-private/near/target/debug/build/cranelift-codegen-c1a82fb675b6a305/out/clif_opt.isle line 928.

            

        

            

                6345
            

            

                
            

            

                
    return v6;

            

        

            

                6346
            

            

                
            

            

                
}

            

        

            

                6347
            

            

                
            

            

                

            

        

            

                6348
            

            

                
            

            

                
// Generated as internal constructor for term udiv.

            

        

            

                6349
            

            

                
            

            

                
pub fn constructor_udiv<C: Context>(ctx: &mut C, arg0: Type, arg1: Value, arg2: Value) -> Value {

            

        

            

                6350
            

            

                
            

            

                
    let v4 = &C::value_array_2_ctor(ctx, arg1, arg2);

            

        

            

                6351
            

            

                
            

            

                
    let v5 = InstructionData::Binary {

            

        

            

                6352
            

            

                
            

            

                
        opcode: Opcode::Udiv,

            

        

            

                6353
            

            

                
            

            

                
        args: v4.clone(),

            

        

            

                6354
            

            

                
            

            

                
    };

            

        

            

                6355
            

            

                
            

            

                
    let v6 = C::make_inst_ctor(ctx, arg0, &v5);

            

        

            

                6356
            

            

                
            

            

                
    // Rule at /home/smcdev/zk-client-private/near/target/debug/build/cranelift-codegen-c1a82fb675b6a305/out/clif_opt.isle line 937.

            

        

            

                6357
            

            

                
            

            

                
    return v6;

            

        

            

                6358
            

            

                
            

            

                
}

            

        

            

                6359
            

            

                
            

            

                

            

        

            

                6360
            

            

                
            

            

                
// Generated as internal constructor for term sdiv.

            

        

            

                6361
            

            

                
            

            

                
pub fn constructor_sdiv<C: Context>(ctx: &mut C, arg0: Type, arg1: Value, arg2: Value) -> Value {

            

        

            

                6362
            

            

                
            

            

                
    let v4 = &C::value_array_2_ctor(ctx, arg1, arg2);

            

        

            

                6363
            

            

                
            

            

                
    let v5 = InstructionData::Binary {

            

        

            

                6364
            

            

                
            

            

                
        opcode: Opcode::Sdiv,

            

        

            

                6365
            

            

                
            

            

                
        args: v4.clone(),

            

        

            

                6366
            

            

                
            

            

                
    };

            

        

            

                6367
            

            

                
            

            

                
    let v6 = C::make_inst_ctor(ctx, arg0, &v5);

            

        

            

                6368
            

            

                
            

            

                
    // Rule at /home/smcdev/zk-client-private/near/target/debug/build/cranelift-codegen-c1a82fb675b6a305/out/clif_opt.isle line 946.

            

        

            

                6369
            

            

                
            

            

                
    return v6;

            

        

            

                6370
            

            

                
            

            

                
}

            

        

            

                6371
            

            

                
            

            

                

            

        

            

                6372
            

            

                
            

            

                
// Generated as internal constructor for term urem.

            

        

            

                6373
            

            

                
            

            

                
pub fn constructor_urem<C: Context>(ctx: &mut C, arg0: Type, arg1: Value, arg2: Value) -> Value {

            

        

            

                6374
            

            

                
            

            

                
    let v4 = &C::value_array_2_ctor(ctx, arg1, arg2);

            

        

            

                6375
            

            

                
            

            

                
    let v5 = InstructionData::Binary {

            

        

            

                6376
            

            

                
            

            

                
        opcode: Opcode::Urem,

            

        

            

                6377
            

            

                
            

            

                
        args: v4.clone(),

            

        

            

                6378
            

            

                
            

            

                
    };

            

        

            

                6379
            

            

                
            

            

                
    let v6 = C::make_inst_ctor(ctx, arg0, &v5);

            

        

            

                6380
            

            

                
            

            

                
    // Rule at /home/smcdev/zk-client-private/near/target/debug/build/cranelift-codegen-c1a82fb675b6a305/out/clif_opt.isle line 955.

            

        

            

                6381
            

            

                
            

            

                
    return v6;

            

        

            

                6382
            

            

                
            

            

                
}

            

        

            

                6383
            

            

                
            

            

                

            

        

            

                6384
            

            

                
            

            

                
// Generated as internal constructor for term srem.

            

        

            

                6385
            

            

                
            

            

                
pub fn constructor_srem<C: Context>(ctx: &mut C, arg0: Type, arg1: Value, arg2: Value) -> Value {

            

        

            

                6386
            

            

                
            

            

                
    let v4 = &C::value_array_2_ctor(ctx, arg1, arg2);

            

        

            

                6387
            

            

                
            

            

                
    let v5 = InstructionData::Binary {

            

        

            

                6388
            

            

                
            

            

                
        opcode: Opcode::Srem,

            

        

            

                6389
            

            

                
            

            

                
        args: v4.clone(),

            

        

            

                6390
            

            

                
            

            

                
    };

            

        

            

                6391
            

            

                
            

            

                
    let v6 = C::make_inst_ctor(ctx, arg0, &v5);

            

        

            

                6392
            

            

                
            

            

                
    // Rule at /home/smcdev/zk-client-private/near/target/debug/build/cranelift-codegen-c1a82fb675b6a305/out/clif_opt.isle line 964.

            

        

            

                6393
            

            

                
            

            

                
    return v6;

            

        

            

                6394
            

            

                
            

            

                
}

            

        

            

                6395
            

            

                
            

            

                

            

        

            

                6396
            

            

                
            

            

                
// Generated as internal constructor for term iadd_imm.

            

        

            

                6397
            

            

                
            

            

                
pub fn constructor_iadd_imm<C: Context>(

            

        

            

                6398
            

            

                
            

            

                
    ctx: &mut C,

            

        

            

                6399
            

            

                
            

            

                
    arg0: Type,

            

        

            

                6400
            

            

                
            

            

                
    arg1: Value,

            

        

            

                6401
            

            

                
            

            

                
    arg2: Imm64,

            

        

            

                6402
            

            

                
            

            

                
) -> Value {

            

        

            

                6403
            

            

                
            

            

                
    let v4 = InstructionData::BinaryImm64 {

            

        

            

                6404
            

            

                
            

            

                
        opcode: Opcode::IaddImm,

            

        

            

                6405
            

            

                
            

            

                
        arg: arg1,

            

        

            

                6406
            

            

                
            

            

                
        imm: arg2,

            

        

            

                6407
            

            

                
            

            

                
    };

            

        

            

                6408
            

            

                
            

            

                
    let v5 = C::make_inst_ctor(ctx, arg0, &v4);

            

        

            

                6409
            

            

                
            

            

                
    // Rule at /home/smcdev/zk-client-private/near/target/debug/build/cranelift-codegen-c1a82fb675b6a305/out/clif_opt.isle line 973.

            

        

            

                6410
            

            

                
            

            

                
    return v5;

            

        

            

                6411
            

            

                
            

            

                
}

            

        

            

                6412
            

            

                
            

            

                

            

        

            

                6413
            

            

                
            

            

                
// Generated as internal constructor for term imul_imm.

            

        

            

                6414
            

            

                
            

            

                
pub fn constructor_imul_imm<C: Context>(

            

        

            

                6415
            

            

                
            

            

                
    ctx: &mut C,

            

        

            

                6416
            

            

                
            

            

                
    arg0: Type,

            

        

            

                6417
            

            

                
            

            

                
    arg1: Value,

            

        

            

                6418
            

            

                
            

            

                
    arg2: Imm64,

            

        

            

                6419
            

            

                
            

            

                
) -> Value {

            

        

            

                6420
            

            

                
            

            

                
    let v4 = InstructionData::BinaryImm64 {

            

        

            

                6421
            

            

                
            

            

                
        opcode: Opcode::ImulImm,

            

        

            

                6422
            

            

                
            

            

                
        arg: arg1,

            

        

            

                6423
            

            

                
            

            

                
        imm: arg2,

            

        

            

                6424
            

            

                
            

            

                
    };

            

        

            

                6425
            

            

                
            

            

                
    let v5 = C::make_inst_ctor(ctx, arg0, &v4);

            

        

            

                6426
            

            

                
            

            

                
    // Rule at /home/smcdev/zk-client-private/near/target/debug/build/cranelift-codegen-c1a82fb675b6a305/out/clif_opt.isle line 982.

            

        

            

                6427
            

            

                
            

            

                
    return v5;

            

        

            

                6428
            

            

                
            

            

                
}

            

        

            

                6429
            

            

                
            

            

                

            

        

            

                6430
            

            

                
            

            

                
// Generated as internal constructor for term udiv_imm.

            

        

            

                6431
            

            

                
            

            

                
pub fn constructor_udiv_imm<C: Context>(

            

        

            

                6432
            

            

                
            

            

                
    ctx: &mut C,

            

        

            

                6433
            

            

                
            

            

                
    arg0: Type,

            

        

            

                6434
            

            

                
            

            

                
    arg1: Value,

            

        

            

                6435
            

            

                
            

            

                
    arg2: Imm64,

            

        

            

                6436
            

            

                
            

            

                
) -> Value {

            

        

            

                6437
            

            

                
            

            

                
    let v4 = InstructionData::BinaryImm64 {

            

        

            

                6438
            

            

                
            

            

                
        opcode: Opcode::UdivImm,

            

        

            

                6439
            

            

                
            

            

                
        arg: arg1,

            

        

            

                6440
            

            

                
            

            

                
        imm: arg2,

            

        

            

                6441
            

            

                
            

            

                
    };

            

        

            

                6442
            

            

                
            

            

                
    let v5 = C::make_inst_ctor(ctx, arg0, &v4);

            

        

            

                6443
            

            

                
            

            

                
    // Rule at /home/smcdev/zk-client-private/near/target/debug/build/cranelift-codegen-c1a82fb675b6a305/out/clif_opt.isle line 991.

            

        

            

                6444
            

            

                
            

            

                
    return v5;

            

        

            

                6445
            

            

                
            

            

                
}

            

        

            

                6446
            

            

                
            

            

                

            

        

            

                6447
            

            

                
            

            

                
// Generated as internal constructor for term sdiv_imm.

            

        

            

                6448
            

            

                
            

            

                
pub fn constructor_sdiv_imm<C: Context>(

            

        

            

                6449
            

            

                
            

            

                
    ctx: &mut C,

            

        

            

                6450
            

            

                
            

            

                
    arg0: Type,

            

        

            

                6451
            

            

                
            

            

                
    arg1: Value,

            

        

            

                6452
            

            

                
            

            

                
    arg2: Imm64,

            

        

            

                6453
            

            

                
            

            

                
) -> Value {

            

        

            

                6454
            

            

                
            

            

                
    let v4 = InstructionData::BinaryImm64 {

            

        

            

                6455
            

            

                
            

            

                
        opcode: Opcode::SdivImm,

            

        

            

                6456
            

            

                
            

            

                
        arg: arg1,

            

        

            

                6457
            

            

                
            

            

                
        imm: arg2,

            

        

            

                6458
            

            

                
            

            

                
    };

            

        

            

                6459
            

            

                
            

            

                
    let v5 = C::make_inst_ctor(ctx, arg0, &v4);

            

        

            

                6460
            

            

                
            

            

                
    // Rule at /home/smcdev/zk-client-private/near/target/debug/build/cranelift-codegen-c1a82fb675b6a305/out/clif_opt.isle line 1000.

            

        

            

                6461
            

            

                
            

            

                
    return v5;

            

        

            

                6462
            

            

                
            

            

                
}

            

        

            

                6463
            

            

                
            

            

                

            

        

            

                6464
            

            

                
            

            

                
// Generated as internal constructor for term urem_imm.

            

        

            

                6465
            

            

                
            

            

                
pub fn constructor_urem_imm<C: Context>(

            

        

            

                6466
            

            

                
            

            

                
    ctx: &mut C,

            

        

            

                6467
            

            

                
            

            

                
    arg0: Type,

            

        

            

                6468
            

            

                
            

            

                
    arg1: Value,

            

        

            

                6469
            

            

                
            

            

                
    arg2: Imm64,

            

        

            

                6470
            

            

                
            

            

                
) -> Value {

            

        

            

                6471
            

            

                
            

            

                
    let v4 = InstructionData::BinaryImm64 {

            

        

            

                6472
            

            

                
            

            

                
        opcode: Opcode::UremImm,

            

        

            

                6473
            

            

                
            

            

                
        arg: arg1,

            

        

            

                6474
            

            

                
            

            

                
        imm: arg2,

            

        

            

                6475
            

            

                
            

            

                
    };

            

        

            

                6476
            

            

                
            

            

                
    let v5 = C::make_inst_ctor(ctx, arg0, &v4);

            

        

            

                6477
            

            

                
            

            

                
    // Rule at /home/smcdev/zk-client-private/near/target/debug/build/cranelift-codegen-c1a82fb675b6a305/out/clif_opt.isle line 1009.

            

        

            

                6478
            

            

                
            

            

                
    return v5;

            

        

            

                6479
            

            

                
            

            

                
}

            

        

            

                6480
            

            

                
            

            

                

            

        

            

                6481
            

            

                
            

            

                
// Generated as internal constructor for term srem_imm.

            

        

            

                6482
            

            

                
            

            

                
pub fn constructor_srem_imm<C: Context>(

            

        

            

                6483
            

            

                
            

            

                
    ctx: &mut C,

            

        

            

                6484
            

            

                
            

            

                
    arg0: Type,

            

        

            

                6485
            

            

                
            

            

                
    arg1: Value,

            

        

            

                6486
            

            

                
            

            

                
    arg2: Imm64,

            

        

            

                6487
            

            

                
            

            

                
) -> Value {

            

        

            

                6488
            

            

                
            

            

                
    let v4 = InstructionData::BinaryImm64 {

            

        

            

                6489
            

            

                
            

            

                
        opcode: Opcode::SremImm,

            

        

            

                6490
            

            

                
            

            

                
        arg: arg1,

            

        

            

                6491
            

            

                
            

            

                
        imm: arg2,

            

        

            

                6492
            

            

                
            

            

                
    };

            

        

            

                6493
            

            

                
            

            

                
    let v5 = C::make_inst_ctor(ctx, arg0, &v4);

            

        

            

                6494
            

            

                
            

            

                
    // Rule at /home/smcdev/zk-client-private/near/target/debug/build/cranelift-codegen-c1a82fb675b6a305/out/clif_opt.isle line 1018.

            

        

            

                6495
            

            

                
            

            

                
    return v5;

            

        

            

                6496
            

            

                
            

            

                
}

            

        

            

                6497
            

            

                
            

            

                

            

        

            

                6498
            

            

                
            

            

                
// Generated as internal constructor for term irsub_imm.

            

        

            

                6499
            

            

                
            

            

                
pub fn constructor_irsub_imm<C: Context>(

            

        

            

                6500
            

            

                
            

            

                
    ctx: &mut C,

            

        

            

                6501
            

            

                
            

            

                
    arg0: Type,

            

        

            

                6502
            

            

                
            

            

                
    arg1: Value,

            

        

            

                6503
            

            

                
            

            

                
    arg2: Imm64,

            

        

            

                6504
            

            

                
            

            

                
) -> Value {

            

        

            

                6505
            

            

                
            

            

                
    let v4 = InstructionData::BinaryImm64 {

            

        

            

                6506
            

            

                
            

            

                
        opcode: Opcode::IrsubImm,

            

        

            

                6507
            

            

                
            

            

                
        arg: arg1,

            

        

            

                6508
            

            

                
            

            

                
        imm: arg2,

            

        

            

                6509
            

            

                
            

            

                
    };

            

        

            

                6510
            

            

                
            

            

                
    let v5 = C::make_inst_ctor(ctx, arg0, &v4);

            

        

            

                6511
            

            

                
            

            

                
    // Rule at /home/smcdev/zk-client-private/near/target/debug/build/cranelift-codegen-c1a82fb675b6a305/out/clif_opt.isle line 1027.

            

        

            

                6512
            

            

                
            

            

                
    return v5;

            

        

            

                6513
            

            

                
            

            

                
}

            

        

            

                6514
            

            

                
            

            

                

            

        

            

                6515
            

            

                
            

            

                
// Generated as internal constructor for term iadd_cin.

            

        

            

                6516
            

            

                
            

            

                
pub fn constructor_iadd_cin<C: Context>(

            

        

            

                6517
            

            

                
            

            

                
    ctx: &mut C,

            

        

            

                6518
            

            

                
            

            

                
    arg0: Type,

            

        

            

                6519
            

            

                
            

            

                
    arg1: Value,

            

        

            

                6520
            

            

                
            

            

                
    arg2: Value,

            

        

            

                6521
            

            

                
            

            

                
    arg3: Value,

            

        

            

                6522
            

            

                
            

            

                
) -> Value {

            

        

            

                6523
            

            

                
            

            

                
    let v5 = &C::value_array_3_ctor(ctx, arg1, arg2, arg3);

            

        

            

                6524
            

            

                
            

            

                
    let v6 = InstructionData::Ternary {

            

        

            

                6525
            

            

                
            

            

                
        opcode: Opcode::IaddCin,

            

        

            

                6526
            

            

                
            

            

                
        args: v5.clone(),

            

        

            

                6527
            

            

                
            

            

                
    };

            

        

            

                6528
            

            

                
            

            

                
    let v7 = C::make_inst_ctor(ctx, arg0, &v6);

            

        

            

                6529
            

            

                
            

            

                
    // Rule at /home/smcdev/zk-client-private/near/target/debug/build/cranelift-codegen-c1a82fb675b6a305/out/clif_opt.isle line 1036.

            

        

            

                6530
            

            

                
            

            

                
    return v7;

            

        

            

                6531
            

            

                
            

            

                
}

            

        

            

                6532
            

            

                
            

            

                

            

        

            

                6533
            

            

                
            

            

                
// Generated as internal constructor for term uadd_overflow_trap.

            

        

            

                6534
            

            

                
            

            

                
pub fn constructor_uadd_overflow_trap<C: Context>(

            

        

            

                6535
            

            

                
            

            

                
    ctx: &mut C,

            

        

            

                6536
            

            

                
            

            

                
    arg0: Type,

            

        

            

                6537
            

            

                
            

            

                
    arg1: Value,

            

        

            

                6538
            

            

                
            

            

                
    arg2: Value,

            

        

            

                6539
            

            

                
            

            

                
    arg3: &TrapCode,

            

        

            

                6540
            

            

                
            

            

                
) -> Value {

            

        

            

                6541
            

            

                
            

            

                
    let v5 = &C::value_array_2_ctor(ctx, arg1, arg2);

            

        

            

                6542
            

            

                
            

            

                
    let v6 = InstructionData::IntAddTrap {

            

        

            

                6543
            

            

                
            

            

                
        opcode: Opcode::UaddOverflowTrap,

            

        

            

                6544
            

            

                
            

            

                
        args: v5.clone(),

            

        

            

                6545
            

            

                
            

            

                
        code: arg3.clone(),

            

        

            

                6546
            

            

                
            

            

                
    };

            

        

            

                6547
            

            

                
            

            

                
    let v7 = C::make_inst_ctor(ctx, arg0, &v6);

            

        

            

                6548
            

            

                
            

            

                
    // Rule at /home/smcdev/zk-client-private/near/target/debug/build/cranelift-codegen-c1a82fb675b6a305/out/clif_opt.isle line 1045.

            

        

            

                6549
            

            

                
            

            

                
    return v7;

            

        

            

                6550
            

            

                
            

            

                
}

            

        

            

                6551
            

            

                
            

            

                

            

        

            

                6552
            

            

                
            

            

                
// Generated as internal constructor for term isub_bin.

            

        

            

                6553
            

            

                
            

            

                
pub fn constructor_isub_bin<C: Context>(

            

        

            

                6554
            

            

                
            

            

                
    ctx: &mut C,

            

        

            

                6555
            

            

                
            

            

                
    arg0: Type,

            

        

            

                6556
            

            

                
            

            

                
    arg1: Value,

            

        

            

                6557
            

            

                
            

            

                
    arg2: Value,

            

        

            

                6558
            

            

                
            

            

                
    arg3: Value,

            

        

            

                6559
            

            

                
            

            

                
) -> Value {

            

        

            

                6560
            

            

                
            

            

                
    let v5 = &C::value_array_3_ctor(ctx, arg1, arg2, arg3);

            

        

            

                6561
            

            

                
            

            

                
    let v6 = InstructionData::Ternary {

            

        

            

                6562
            

            

                
            

            

                
        opcode: Opcode::IsubBin,

            

        

            

                6563
            

            

                
            

            

                
        args: v5.clone(),

            

        

            

                6564
            

            

                
            

            

                
    };

            

        

            

                6565
            

            

                
            

            

                
    let v7 = C::make_inst_ctor(ctx, arg0, &v6);

            

        

            

                6566
            

            

                
            

            

                
    // Rule at /home/smcdev/zk-client-private/near/target/debug/build/cranelift-codegen-c1a82fb675b6a305/out/clif_opt.isle line 1054.

            

        

            

                6567
            

            

                
            

            

                
    return v7;

            

        

            

                6568
            

            

                
            

            

                
}

            

        

            

                6569
            

            

                
            

            

                

            

        

            

                6570
            

            

                
            

            

                
// Generated as internal constructor for term band.

            

        

            

                6571
            

            

                
            

            

                
pub fn constructor_band<C: Context>(ctx: &mut C, arg0: Type, arg1: Value, arg2: Value) -> Value {

            

        

            

                6572
            

            

                
            

            

                
    let v4 = &C::value_array_2_ctor(ctx, arg1, arg2);

            

        

            

                6573
            

            

                
            

            

                
    let v5 = InstructionData::Binary {

            

        

            

                6574
            

            

                
            

            

                
        opcode: Opcode::Band,

            

        

            

                6575
            

            

                
            

            

                
        args: v4.clone(),

            

        

            

                6576
            

            

                
            

            

                
    };

            

        

            

                6577
            

            

                
            

            

                
    let v6 = C::make_inst_ctor(ctx, arg0, &v5);

            

        

            

                6578
            

            

                
            

            

                
    // Rule at /home/smcdev/zk-client-private/near/target/debug/build/cranelift-codegen-c1a82fb675b6a305/out/clif_opt.isle line 1063.

            

        

            

                6579
            

            

                
            

            

                
    return v6;

            

        

            

                6580
            

            

                
            

            

                
}

            

        

            

                6581
            

            

                
            

            

                

            

        

            

                6582
            

            

                
            

            

                
// Generated as internal constructor for term bor.

            

        

            

                6583
            

            

                
            

            

                
pub fn constructor_bor<C: Context>(ctx: &mut C, arg0: Type, arg1: Value, arg2: Value) -> Value {

            

        

            

                6584
            

            

                
            

            

                
    let v4 = &C::value_array_2_ctor(ctx, arg1, arg2);

            

        

            

                6585
            

            

                
            

            

                
    let v5 = InstructionData::Binary {

            

        

            

                6586
            

            

                
            

            

                
        opcode: Opcode::Bor,

            

        

            

                6587
            

            

                
            

            

                
        args: v4.clone(),

            

        

            

                6588
            

            

                
            

            

                
    };

            

        

            

                6589
            

            

                
            

            

                
    let v6 = C::make_inst_ctor(ctx, arg0, &v5);

            

        

            

                6590
            

            

                
            

            

                
    // Rule at /home/smcdev/zk-client-private/near/target/debug/build/cranelift-codegen-c1a82fb675b6a305/out/clif_opt.isle line 1072.

            

        

            

                6591
            

            

                
            

            

                
    return v6;

            

        

            

                6592
            

            

                
            

            

                
}

            

        

            

                6593
            

            

                
            

            

                

            

        

            

                6594
            

            

                
            

            

                
// Generated as internal constructor for term bxor.

            

        

            

                6595
            

            

                
            

            

                
pub fn constructor_bxor<C: Context>(ctx: &mut C, arg0: Type, arg1: Value, arg2: Value) -> Value {

            

        

            

                6596
            

            

                
            

            

                
    let v4 = &C::value_array_2_ctor(ctx, arg1, arg2);

            

        

            

                6597
            

            

                
            

            

                
    let v5 = InstructionData::Binary {

            

        

            

                6598
            

            

                
            

            

                
        opcode: Opcode::Bxor,

            

        

            

                6599
            

            

                
            

            

                
        args: v4.clone(),

            

        

            

                6600
            

            

                
            

            

                
    };

            

        

            

                6601
            

            

                
            

            

                
    let v6 = C::make_inst_ctor(ctx, arg0, &v5);

            

        

            

                6602
            

            

                
            

            

                
    // Rule at /home/smcdev/zk-client-private/near/target/debug/build/cranelift-codegen-c1a82fb675b6a305/out/clif_opt.isle line 1081.

            

        

            

                6603
            

            

                
            

            

                
    return v6;

            

        

            

                6604
            

            

                
            

            

                
}

            

        

            

                6605
            

            

                
            

            

                

            

        

            

                6606
            

            

                
            

            

                
// Generated as internal constructor for term bnot.

            

        

            

                6607
            

            

                
            

            

                
pub fn constructor_bnot<C: Context>(ctx: &mut C, arg0: Type, arg1: Value) -> Value {

            

        

            

                6608
            

            

                
            

            

                
    let v3 = InstructionData::Unary {

            

        

            

                6609
            

            

                
            

            

                
        opcode: Opcode::Bnot,

            

        

            

                6610
            

            

                
            

            

                
        arg: arg1,

            

        

            

                6611
            

            

                
            

            

                
    };

            

        

            

                6612
            

            

                
            

            

                
    let v4 = C::make_inst_ctor(ctx, arg0, &v3);

            

        

            

                6613
            

            

                
            

            

                
    // Rule at /home/smcdev/zk-client-private/near/target/debug/build/cranelift-codegen-c1a82fb675b6a305/out/clif_opt.isle line 1090.

            

        

            

                6614
            

            

                
            

            

                
    return v4;

            

        

            

                6615
            

            

                
            

            

                
}

            

        

            

                6616
            

            

                
            

            

                

            

        

            

                6617
            

            

                
            

            

                
// Generated as internal constructor for term band_not.

            

        

            

                6618
            

            

                
            

            

                
pub fn constructor_band_not<C: Context>(

            

        

            

                6619
            

            

                
            

            

                
    ctx: &mut C,

            

        

            

                6620
            

            

                
            

            

                
    arg0: Type,

            

        

            

                6621
            

            

                
            

            

                
    arg1: Value,

            

        

            

                6622
            

            

                
            

            

                
    arg2: Value,

            

        

            

                6623
            

            

                
            

            

                
) -> Value {

            

        

            

                6624
            

            

                
            

            

                
    let v4 = &C::value_array_2_ctor(ctx, arg1, arg2);

            

        

            

                6625
            

            

                
            

            

                
    let v5 = InstructionData::Binary {

            

        

            

                6626
            

            

                
            

            

                
        opcode: Opcode::BandNot,

            

        

            

                6627
            

            

                
            

            

                
        args: v4.clone(),

            

        

            

                6628
            

            

                
            

            

                
    };

            

        

            

                6629
            

            

                
            

            

                
    let v6 = C::make_inst_ctor(ctx, arg0, &v5);

            

        

            

                6630
            

            

                
            

            

                
    // Rule at /home/smcdev/zk-client-private/near/target/debug/build/cranelift-codegen-c1a82fb675b6a305/out/clif_opt.isle line 1099.

            

        

            

                6631
            

            

                
            

            

                
    return v6;

            

        

            

                6632
            

            

                
            

            

                
}

            

        

            

                6633
            

            

                
            

            

                

            

        

            

                6634
            

            

                
            

            

                
// Generated as internal constructor for term bor_not.

            

        

            

                6635
            

            

                
            

            

                
pub fn constructor_bor_not<C: Context>(ctx: &mut C, arg0: Type, arg1: Value, arg2: Value) -> Value {

            

        

            

                6636
            

            

                
            

            

                
    let v4 = &C::value_array_2_ctor(ctx, arg1, arg2);

            

        

            

                6637
            

            

                
            

            

                
    let v5 = InstructionData::Binary {

            

        

            

                6638
            

            

                
            

            

                
        opcode: Opcode::BorNot,

            

        

            

                6639
            

            

                
            

            

                
        args: v4.clone(),

            

        

            

                6640
            

            

                
            

            

                
    };

            

        

            

                6641
            

            

                
            

            

                
    let v6 = C::make_inst_ctor(ctx, arg0, &v5);

            

        

            

                6642
            

            

                
            

            

                
    // Rule at /home/smcdev/zk-client-private/near/target/debug/build/cranelift-codegen-c1a82fb675b6a305/out/clif_opt.isle line 1108.

            

        

            

                6643
            

            

                
            

            

                
    return v6;

            

        

            

                6644
            

            

                
            

            

                
}

            

        

            

                6645
            

            

                
            

            

                

            

        

            

                6646
            

            

                
            

            

                
// Generated as internal constructor for term bxor_not.

            

        

            

                6647
            

            

                
            

            

                
pub fn constructor_bxor_not<C: Context>(

            

        

            

                6648
            

            

                
            

            

                
    ctx: &mut C,

            

        

            

                6649
            

            

                
            

            

                
    arg0: Type,

            

        

            

                6650
            

            

                
            

            

                
    arg1: Value,

            

        

            

                6651
            

            

                
            

            

                
    arg2: Value,

            

        

            

                6652
            

            

                
            

            

                
) -> Value {

            

        

            

                6653
            

            

                
            

            

                
    let v4 = &C::value_array_2_ctor(ctx, arg1, arg2);

            

        

            

                6654
            

            

                
            

            

                
    let v5 = InstructionData::Binary {

            

        

            

                6655
            

            

                
            

            

                
        opcode: Opcode::BxorNot,

            

        

            

                6656
            

            

                
            

            

                
        args: v4.clone(),

            

        

            

                6657
            

            

                
            

            

                
    };

            

        

            

                6658
            

            

                
            

            

                
    let v6 = C::make_inst_ctor(ctx, arg0, &v5);

            

        

            

                6659
            

            

                
            

            

                
    // Rule at /home/smcdev/zk-client-private/near/target/debug/build/cranelift-codegen-c1a82fb675b6a305/out/clif_opt.isle line 1117.

            

        

            

                6660
            

            

                
            

            

                
    return v6;

            

        

            

                6661
            

            

                
            

            

                
}

            

        

            

                6662
            

            

                
            

            

                

            

        

            

                6663
            

            

                
            

            

                
// Generated as internal constructor for term band_imm.

            

        

            

                6664
            

            

                
            

            

                
pub fn constructor_band_imm<C: Context>(

            

        

            

                6665
            

            

                
            

            

                
    ctx: &mut C,

            

        

            

                6666
            

            

                
            

            

                
    arg0: Type,

            

        

            

                6667
            

            

                
            

            

                
    arg1: Value,

            

        

            

                6668
            

            

                
            

            

                
    arg2: Imm64,

            

        

            

                6669
            

            

                
            

            

                
) -> Value {

            

        

            

                6670
            

            

                
            

            

                
    let v4 = InstructionData::BinaryImm64 {

            

        

            

                6671
            

            

                
            

            

                
        opcode: Opcode::BandImm,

            

        

            

                6672
            

            

                
            

            

                
        arg: arg1,

            

        

            

                6673
            

            

                
            

            

                
        imm: arg2,

            

        

            

                6674
            

            

                
            

            

                
    };

            

        

            

                6675
            

            

                
            

            

                
    let v5 = C::make_inst_ctor(ctx, arg0, &v4);

            

        

            

                6676
            

            

                
            

            

                
    // Rule at /home/smcdev/zk-client-private/near/target/debug/build/cranelift-codegen-c1a82fb675b6a305/out/clif_opt.isle line 1126.

            

        

            

                6677
            

            

                
            

            

                
    return v5;

            

        

            

                6678
            

            

                
            

            

                
}

            

        

            

                6679
            

            

                
            

            

                

            

        

            

                6680
            

            

                
            

            

                
// Generated as internal constructor for term bor_imm.

            

        

            

                6681
            

            

                
            

            

                
pub fn constructor_bor_imm<C: Context>(ctx: &mut C, arg0: Type, arg1: Value, arg2: Imm64) -> Value {

            

        

            

                6682
            

            

                
            

            

                
    let v4 = InstructionData::BinaryImm64 {

            

        

            

                6683
            

            

                
            

            

                
        opcode: Opcode::BorImm,

            

        

            

                6684
            

            

                
            

            

                
        arg: arg1,

            

        

            

                6685
            

            

                
            

            

                
        imm: arg2,

            

        

            

                6686
            

            

                
            

            

                
    };

            

        

            

                6687
            

            

                
            

            

                
    let v5 = C::make_inst_ctor(ctx, arg0, &v4);

            

        

            

                6688
            

            

                
            

            

                
    // Rule at /home/smcdev/zk-client-private/near/target/debug/build/cranelift-codegen-c1a82fb675b6a305/out/clif_opt.isle line 1135.

            

        

            

                6689
            

            

                
            

            

                
    return v5;

            

        

            

                6690
            

            

                
            

            

                
}

            

        

            

                6691
            

            

                
            

            

                

            

        

            

                6692
            

            

                
            

            

                
// Generated as internal constructor for term bxor_imm.

            

        

            

                6693
            

            

                
            

            

                
pub fn constructor_bxor_imm<C: Context>(

            

        

            

                6694
            

            

                
            

            

                
    ctx: &mut C,

            

        

            

                6695
            

            

                
            

            

                
    arg0: Type,

            

        

            

                6696
            

            

                
            

            

                
    arg1: Value,

            

        

            

                6697
            

            

                
            

            

                
    arg2: Imm64,

            

        

            

                6698
            

            

                
            

            

                
) -> Value {

            

        

            

                6699
            

            

                
            

            

                
    let v4 = InstructionData::BinaryImm64 {

            

        

            

                6700
            

            

                
            

            

                
        opcode: Opcode::BxorImm,

            

        

            

                6701
            

            

                
            

            

                
        arg: arg1,

            

        

            

                6702
            

            

                
            

            

                
        imm: arg2,

            

        

            

                6703
            

            

                
            

            

                
    };

            

        

            

                6704
            

            

                
            

            

                
    let v5 = C::make_inst_ctor(ctx, arg0, &v4);

            

        

            

                6705
            

            

                
            

            

                
    // Rule at /home/smcdev/zk-client-private/near/target/debug/build/cranelift-codegen-c1a82fb675b6a305/out/clif_opt.isle line 1144.

            

        

            

                6706
            

            

                
            

            

                
    return v5;

            

        

            

                6707
            

            

                
            

            

                
}

            

        

            

                6708
            

            

                
            

            

                

            

        

            

                6709
            

            

                
            

            

                
// Generated as internal constructor for term rotl.

            

        

            

                6710
            

            

                
            

            

                
pub fn constructor_rotl<C: Context>(ctx: &mut C, arg0: Type, arg1: Value, arg2: Value) -> Value {

            

        

            

                6711
            

            

                
            

            

                
    let v4 = &C::value_array_2_ctor(ctx, arg1, arg2);

            

        

            

                6712
            

            

                
            

            

                
    let v5 = InstructionData::Binary {

            

        

            

                6713
            

            

                
            

            

                
        opcode: Opcode::Rotl,

            

        

            

                6714
            

            

                
            

            

                
        args: v4.clone(),

            

        

            

                6715
            

            

                
            

            

                
    };

            

        

            

                6716
            

            

                
            

            

                
    let v6 = C::make_inst_ctor(ctx, arg0, &v5);

            

        

            

                6717
            

            

                
            

            

                
    // Rule at /home/smcdev/zk-client-private/near/target/debug/build/cranelift-codegen-c1a82fb675b6a305/out/clif_opt.isle line 1153.

            

        

            

                6718
            

            

                
            

            

                
    return v6;

            

        

            

                6719
            

            

                
            

            

                
}

            

        

            

                6720
            

            

                
            

            

                

            

        

            

                6721
            

            

                
            

            

                
// Generated as internal constructor for term rotr.

            

        

            

                6722
            

            

                
            

            

                
pub fn constructor_rotr<C: Context>(ctx: &mut C, arg0: Type, arg1: Value, arg2: Value) -> Value {

            

        

            

                6723
            

            

                
            

            

                
    let v4 = &C::value_array_2_ctor(ctx, arg1, arg2);

            

        

            

                6724
            

            

                
            

            

                
    let v5 = InstructionData::Binary {

            

        

            

                6725
            

            

                
            

            

                
        opcode: Opcode::Rotr,

            

        

            

                6726
            

            

                
            

            

                
        args: v4.clone(),

            

        

            

                6727
            

            

                
            

            

                
    };

            

        

            

                6728
            

            

                
            

            

                
    let v6 = C::make_inst_ctor(ctx, arg0, &v5);

            

        

            

                6729
            

            

                
            

            

                
    // Rule at /home/smcdev/zk-client-private/near/target/debug/build/cranelift-codegen-c1a82fb675b6a305/out/clif_opt.isle line 1162.

            

        

            

                6730
            

            

                
            

            

                
    return v6;

            

        

            

                6731
            

            

                
            

            

                
}

            

        

            

                6732
            

            

                
            

            

                

            

        

            

                6733
            

            

                
            

            

                
// Generated as internal constructor for term rotl_imm.

            

        

            

                6734
            

            

                
            

            

                
pub fn constructor_rotl_imm<C: Context>(

            

        

            

                6735
            

            

                
            

            

                
    ctx: &mut C,

            

        

            

                6736
            

            

                
            

            

                
    arg0: Type,

            

        

            

                6737
            

            

                
            

            

                
    arg1: Value,

            

        

            

                6738
            

            

                
            

            

                
    arg2: Imm64,

            

        

            

                6739
            

            

                
            

            

                
) -> Value {

            

        

            

                6740
            

            

                
            

            

                
    let v4 = InstructionData::BinaryImm64 {

            

        

            

                6741
            

            

                
            

            

                
        opcode: Opcode::RotlImm,

            

        

            

                6742
            

            

                
            

            

                
        arg: arg1,

            

        

            

                6743
            

            

                
            

            

                
        imm: arg2,

            

        

            

                6744
            

            

                
            

            

                
    };

            

        

            

                6745
            

            

                
            

            

                
    let v5 = C::make_inst_ctor(ctx, arg0, &v4);

            

        

            

                6746
            

            

                
            

            

                
    // Rule at /home/smcdev/zk-client-private/near/target/debug/build/cranelift-codegen-c1a82fb675b6a305/out/clif_opt.isle line 1171.

            

        

            

                6747
            

            

                
            

            

                
    return v5;

            

        

            

                6748
            

            

                
            

            

                
}

            

        

            

                6749
            

            

                
            

            

                

            

        

            

                6750
            

            

                
            

            

                
// Generated as internal constructor for term rotr_imm.

            

        

            

                6751
            

            

                
            

            

                
pub fn constructor_rotr_imm<C: Context>(

            

        

            

                6752
            

            

                
            

            

                
    ctx: &mut C,

            

        

            

                6753
            

            

                
            

            

                
    arg0: Type,

            

        

            

                6754
            

            

                
            

            

                
    arg1: Value,

            

        

            

                6755
            

            

                
            

            

                
    arg2: Imm64,

            

        

            

                6756
            

            

                
            

            

                
) -> Value {

            

        

            

                6757
            

            

                
            

            

                
    let v4 = InstructionData::BinaryImm64 {

            

        

            

                6758
            

            

                
            

            

                
        opcode: Opcode::RotrImm,

            

        

            

                6759
            

            

                
            

            

                
        arg: arg1,

            

        

            

                6760
            

            

                
            

            

                
        imm: arg2,

            

        

            

                6761
            

            

                
            

            

                
    };

            

        

            

                6762
            

            

                
            

            

                
    let v5 = C::make_inst_ctor(ctx, arg0, &v4);

            

        

            

                6763
            

            

                
            

            

                
    // Rule at /home/smcdev/zk-client-private/near/target/debug/build/cranelift-codegen-c1a82fb675b6a305/out/clif_opt.isle line 1180.

            

        

            

                6764
            

            

                
            

            

                
    return v5;

            

        

            

                6765
            

            

                
            

            

                
}

            

        

            

                6766
            

            

                
            

            

                

            

        

            

                6767
            

            

                
            

            

                
// Generated as internal constructor for term ishl.

            

        

            

                6768
            

            

                
            

            

                
pub fn constructor_ishl<C: Context>(ctx: &mut C, arg0: Type, arg1: Value, arg2: Value) -> Value {

            

        

            

                6769
            

            

                
            

            

                
    let v4 = &C::value_array_2_ctor(ctx, arg1, arg2);

            

        

            

                6770
            

            

                
            

            

                
    let v5 = InstructionData::Binary {

            

        

            

                6771
            

            

                
            

            

                
        opcode: Opcode::Ishl,

            

        

            

                6772
            

            

                
            

            

                
        args: v4.clone(),

            

        

            

                6773
            

            

                
            

            

                
    };

            

        

            

                6774
            

            

                
            

            

                
    let v6 = C::make_inst_ctor(ctx, arg0, &v5);

            

        

            

                6775
            

            

                
            

            

                
    // Rule at /home/smcdev/zk-client-private/near/target/debug/build/cranelift-codegen-c1a82fb675b6a305/out/clif_opt.isle line 1189.

            

        

            

                6776
            

            

                
            

            

                
    return v6;

            

        

            

                6777
            

            

                
            

            

                
}

            

        

            

                6778
            

            

                
            

            

                

            

        

            

                6779
            

            

                
            

            

                
// Generated as internal constructor for term ushr.

            

        

            

                6780
            

            

                
            

            

                
pub fn constructor_ushr<C: Context>(ctx: &mut C, arg0: Type, arg1: Value, arg2: Value) -> Value {

            

        

            

                6781
            

            

                
            

            

                
    let v4 = &C::value_array_2_ctor(ctx, arg1, arg2);

            

        

            

                6782
            

            

                
            

            

                
    let v5 = InstructionData::Binary {

            

        

            

                6783
            

            

                
            

            

                
        opcode: Opcode::Ushr,

            

        

            

                6784
            

            

                
            

            

                
        args: v4.clone(),

            

        

            

                6785
            

            

                
            

            

                
    };

            

        

            

                6786
            

            

                
            

            

                
    let v6 = C::make_inst_ctor(ctx, arg0, &v5);

            

        

            

                6787
            

            

                
            

            

                
    // Rule at /home/smcdev/zk-client-private/near/target/debug/build/cranelift-codegen-c1a82fb675b6a305/out/clif_opt.isle line 1198.

            

        

            

                6788
            

            

                
            

            

                
    return v6;

            

        

            

                6789
            

            

                
            

            

                
}

            

        

            

                6790
            

            

                
            

            

                

            

        

            

                6791
            

            

                
            

            

                
// Generated as internal constructor for term sshr.

            

        

            

                6792
            

            

                
            

            

                
pub fn constructor_sshr<C: Context>(ctx: &mut C, arg0: Type, arg1: Value, arg2: Value) -> Value {

            

        

            

                6793
            

            

                
            

            

                
    let v4 = &C::value_array_2_ctor(ctx, arg1, arg2);

            

        

            

                6794
            

            

                
            

            

                
    let v5 = InstructionData::Binary {

            

        

            

                6795
            

            

                
            

            

                
        opcode: Opcode::Sshr,

            

        

            

                6796
            

            

                
            

            

                
        args: v4.clone(),

            

        

            

                6797
            

            

                
            

            

                
    };

            

        

            

                6798
            

            

                
            

            

                
    let v6 = C::make_inst_ctor(ctx, arg0, &v5);

            

        

            

                6799
            

            

                
            

            

                
    // Rule at /home/smcdev/zk-client-private/near/target/debug/build/cranelift-codegen-c1a82fb675b6a305/out/clif_opt.isle line 1207.

            

        

            

                6800
            

            

                
            

            

                
    return v6;

            

        

            

                6801
            

            

                
            

            

                
}

            

        

            

                6802
            

            

                
            

            

                

            

        

            

                6803
            

            

                
            

            

                
// Generated as internal constructor for term ishl_imm.

            

        

            

                6804
            

            

                
            

            

                
pub fn constructor_ishl_imm<C: Context>(

            

        

            

                6805
            

            

                
            

            

                
    ctx: &mut C,

            

        

            

                6806
            

            

                
            

            

                
    arg0: Type,

            

        

            

                6807
            

            

                
            

            

                
    arg1: Value,

            

        

            

                6808
            

            

                
            

            

                
    arg2: Imm64,

            

        

            

                6809
            

            

                
            

            

                
) -> Value {

            

        

            

                6810
            

            

                
            

            

                
    let v4 = InstructionData::BinaryImm64 {

            

        

            

                6811
            

            

                
            

            

                
        opcode: Opcode::IshlImm,

            

        

            

                6812
            

            

                
            

            

                
        arg: arg1,

            

        

            

                6813
            

            

                
            

            

                
        imm: arg2,

            

        

            

                6814
            

            

                
            

            

                
    };

            

        

            

                6815
            

            

                
            

            

                
    let v5 = C::make_inst_ctor(ctx, arg0, &v4);

            

        

            

                6816
            

            

                
            

            

                
    // Rule at /home/smcdev/zk-client-private/near/target/debug/build/cranelift-codegen-c1a82fb675b6a305/out/clif_opt.isle line 1216.

            

        

            

                6817
            

            

                
            

            

                
    return v5;

            

        

            

                6818
            

            

                
            

            

                
}

            

        

            

                6819
            

            

                
            

            

                

            

        

            

                6820
            

            

                
            

            

                
// Generated as internal constructor for term ushr_imm.

            

        

            

                6821
            

            

                
            

            

                
pub fn constructor_ushr_imm<C: Context>(

            

        

            

                6822
            

            

                
            

            

                
    ctx: &mut C,

            

        

            

                6823
            

            

                
            

            

                
    arg0: Type,

            

        

            

                6824
            

            

                
            

            

                
    arg1: Value,

            

        

            

                6825
            

            

                
            

            

                
    arg2: Imm64,

            

        

            

                6826
            

            

                
            

            

                
) -> Value {

            

        

            

                6827
            

            

                
            

            

                
    let v4 = InstructionData::BinaryImm64 {

            

        

            

                6828
            

            

                
            

            

                
        opcode: Opcode::UshrImm,

            

        

            

                6829
            

            

                
            

            

                
        arg: arg1,

            

        

            

                6830
            

            

                
            

            

                
        imm: arg2,

            

        

            

                6831
            

            

                
            

            

                
    };

            

        

            

                6832
            

            

                
            

            

                
    let v5 = C::make_inst_ctor(ctx, arg0, &v4);

            

        

            

                6833
            

            

                
            

            

                
    // Rule at /home/smcdev/zk-client-private/near/target/debug/build/cranelift-codegen-c1a82fb675b6a305/out/clif_opt.isle line 1225.

            

        

            

                6834
            

            

                
            

            

                
    return v5;

            

        

            

                6835
            

            

                
            

            

                
}

            

        

            

                6836
            

            

                
            

            

                

            

        

            

                6837
            

            

                
            

            

                
// Generated as internal constructor for term sshr_imm.

            

        

            

                6838
            

            

                
            

            

                
pub fn constructor_sshr_imm<C: Context>(

            

        

            

                6839
            

            

                
            

            

                
    ctx: &mut C,

            

        

            

                6840
            

            

                
            

            

                
    arg0: Type,

            

        

            

                6841
            

            

                
            

            

                
    arg1: Value,

            

        

            

                6842
            

            

                
            

            

                
    arg2: Imm64,

            

        

            

                6843
            

            

                
            

            

                
) -> Value {

            

        

            

                6844
            

            

                
            

            

                
    let v4 = InstructionData::BinaryImm64 {

            

        

            

                6845
            

            

                
            

            

                
        opcode: Opcode::SshrImm,

            

        

            

                6846
            

            

                
            

            

                
        arg: arg1,

            

        

            

                6847
            

            

                
            

            

                
        imm: arg2,

            

        

            

                6848
            

            

                
            

            

                
    };

            

        

            

                6849
            

            

                
            

            

                
    let v5 = C::make_inst_ctor(ctx, arg0, &v4);

            

        

            

                6850
            

            

                
            

            

                
    // Rule at /home/smcdev/zk-client-private/near/target/debug/build/cranelift-codegen-c1a82fb675b6a305/out/clif_opt.isle line 1234.

            

        

            

                6851
            

            

                
            

            

                
    return v5;

            

        

            

                6852
            

            

                
            

            

                
}

            

        

            

                6853
            

            

                
            

            

                

            

        

            

                6854
            

            

                
            

            

                
// Generated as internal constructor for term bitrev.

            

        

            

                6855
            

            

                
            

            

                
pub fn constructor_bitrev<C: Context>(ctx: &mut C, arg0: Type, arg1: Value) -> Value {

            

        

            

                6856
            

            

                
            

            

                
    let v3 = InstructionData::Unary {

            

        

            

                6857
            

            

                
            

            

                
        opcode: Opcode::Bitrev,

            

        

            

                6858
            

            

                
            

            

                
        arg: arg1,

            

        

            

                6859
            

            

                
            

            

                
    };

            

        

            

                6860
            

            

                
            

            

                
    let v4 = C::make_inst_ctor(ctx, arg0, &v3);

            

        

            

                6861
            

            

                
            

            

                
    // Rule at /home/smcdev/zk-client-private/near/target/debug/build/cranelift-codegen-c1a82fb675b6a305/out/clif_opt.isle line 1243.

            

        

            

                6862
            

            

                
            

            

                
    return v4;

            

        

            

                6863
            

            

                
            

            

                
}

            

        

            

                6864
            

            

                
            

            

                

            

        

            

                6865
            

            

                
            

            

                
// Generated as internal constructor for term clz.

            

        

            

                6866
            

            

                
            

            

                
pub fn constructor_clz<C: Context>(ctx: &mut C, arg0: Type, arg1: Value) -> Value {

            

        

            

                6867
            

            

                
            

            

                
    let v3 = InstructionData::Unary {

            

        

            

                6868
            

            

                
            

            

                
        opcode: Opcode::Clz,

            

        

            

                6869
            

            

                
            

            

                
        arg: arg1,

            

        

            

                6870
            

            

                
            

            

                
    };

            

        

            

                6871
            

            

                
            

            

                
    let v4 = C::make_inst_ctor(ctx, arg0, &v3);

            

        

            

                6872
            

            

                
            

            

                
    // Rule at /home/smcdev/zk-client-private/near/target/debug/build/cranelift-codegen-c1a82fb675b6a305/out/clif_opt.isle line 1252.

            

        

            

                6873
            

            

                
            

            

                
    return v4;

            

        

            

                6874
            

            

                
            

            

                
}

            

        

            

                6875
            

            

                
            

            

                

            

        

            

                6876
            

            

                
            

            

                
// Generated as internal constructor for term cls.

            

        

            

                6877
            

            

                
            

            

                
pub fn constructor_cls<C: Context>(ctx: &mut C, arg0: Type, arg1: Value) -> Value {

            

        

            

                6878
            

            

                
            

            

                
    let v3 = InstructionData::Unary {

            

        

            

                6879
            

            

                
            

            

                
        opcode: Opcode::Cls,

            

        

            

                6880
            

            

                
            

            

                
        arg: arg1,

            

        

            

                6881
            

            

                
            

            

                
    };

            

        

            

                6882
            

            

                
            

            

                
    let v4 = C::make_inst_ctor(ctx, arg0, &v3);

            

        

            

                6883
            

            

                
            

            

                
    // Rule at /home/smcdev/zk-client-private/near/target/debug/build/cranelift-codegen-c1a82fb675b6a305/out/clif_opt.isle line 1261.

            

        

            

                6884
            

            

                
            

            

                
    return v4;

            

        

            

                6885
            

            

                
            

            

                
}

            

        

            

                6886
            

            

                
            

            

                

            

        

            

                6887
            

            

                
            

            

                
// Generated as internal constructor for term ctz.

            

        

            

                6888
            

            

                
            

            

                
pub fn constructor_ctz<C: Context>(ctx: &mut C, arg0: Type, arg1: Value) -> Value {

            

        

            

                6889
            

            

                
            

            

                
    let v3 = InstructionData::Unary {

            

        

            

                6890
            

            

                
            

            

                
        opcode: Opcode::Ctz,

            

        

            

                6891
            

            

                
            

            

                
        arg: arg1,

            

        

            

                6892
            

            

                
            

            

                
    };

            

        

            

                6893
            

            

                
            

            

                
    let v4 = C::make_inst_ctor(ctx, arg0, &v3);

            

        

            

                6894
            

            

                
            

            

                
    // Rule at /home/smcdev/zk-client-private/near/target/debug/build/cranelift-codegen-c1a82fb675b6a305/out/clif_opt.isle line 1270.

            

        

            

                6895
            

            

                
            

            

                
    return v4;

            

        

            

                6896
            

            

                
            

            

                
}

            

        

            

                6897
            

            

                
            

            

                

            

        

            

                6898
            

            

                
            

            

                
// Generated as internal constructor for term bswap.

            

        

            

                6899
            

            

                
            

            

                
pub fn constructor_bswap<C: Context>(ctx: &mut C, arg0: Type, arg1: Value) -> Value {

            

        

            

                6900
            

            

                
            

            

                
    let v3 = InstructionData::Unary {

            

        

            

                6901
            

            

                
            

            

                
        opcode: Opcode::Bswap,

            

        

            

                6902
            

            

                
            

            

                
        arg: arg1,

            

        

            

                6903
            

            

                
            

            

                
    };

            

        

            

                6904
            

            

                
            

            

                
    let v4 = C::make_inst_ctor(ctx, arg0, &v3);

            

        

            

                6905
            

            

                
            

            

                
    // Rule at /home/smcdev/zk-client-private/near/target/debug/build/cranelift-codegen-c1a82fb675b6a305/out/clif_opt.isle line 1279.

            

        

            

                6906
            

            

                
            

            

                
    return v4;

            

        

            

                6907
            

            

                
            

            

                
}

            

        

            

                6908
            

            

                
            

            

                

            

        

            

                6909
            

            

                
            

            

                
// Generated as internal constructor for term popcnt.

            

        

            

                6910
            

            

                
            

            

                
pub fn constructor_popcnt<C: Context>(ctx: &mut C, arg0: Type, arg1: Value) -> Value {

            

        

            

                6911
            

            

                
            

            

                
    let v3 = InstructionData::Unary {

            

        

            

                6912
            

            

                
            

            

                
        opcode: Opcode::Popcnt,

            

        

            

                6913
            

            

                
            

            

                
        arg: arg1,

            

        

            

                6914
            

            

                
            

            

                
    };

            

        

            

                6915
            

            

                
            

            

                
    let v4 = C::make_inst_ctor(ctx, arg0, &v3);

            

        

            

                6916
            

            

                
            

            

                
    // Rule at /home/smcdev/zk-client-private/near/target/debug/build/cranelift-codegen-c1a82fb675b6a305/out/clif_opt.isle line 1288.

            

        

            

                6917
            

            

                
            

            

                
    return v4;

            

        

            

                6918
            

            

                
            

            

                
}

            

        

            

                6919
            

            

                
            

            

                

            

        

            

                6920
            

            

                
            

            

                
// Generated as internal constructor for term fcmp.

            

        

            

                6921
            

            

                
            

            

                
pub fn constructor_fcmp<C: Context>(

            

        

            

                6922
            

            

                
            

            

                
    ctx: &mut C,

            

        

            

                6923
            

            

                
            

            

                
    arg0: Type,

            

        

            

                6924
            

            

                
            

            

                
    arg1: &FloatCC,

            

        

            

                6925
            

            

                
            

            

                
    arg2: Value,

            

        

            

                6926
            

            

                
            

            

                
    arg3: Value,

            

        

            

                6927
            

            

                
            

            

                
) -> Value {

            

        

            

                6928
            

            

                
            

            

                
    let v5 = &C::value_array_2_ctor(ctx, arg2, arg3);

            

        

            

                6929
            

            

                
            

            

                
    let v6 = InstructionData::FloatCompare {

            

        

            

                6930
            

            

                
            

            

                
        opcode: Opcode::Fcmp,

            

        

            

                6931
            

            

                
            

            

                
        args: v5.clone(),

            

        

            

                6932
            

            

                
            

            

                
        cond: arg1.clone(),

            

        

            

                6933
            

            

                
            

            

                
    };

            

        

            

                6934
            

            

                
            

            

                
    let v7 = C::make_inst_ctor(ctx, arg0, &v6);

            

        

            

                6935
            

            

                
            

            

                
    // Rule at /home/smcdev/zk-client-private/near/target/debug/build/cranelift-codegen-c1a82fb675b6a305/out/clif_opt.isle line 1297.

            

        

            

                6936
            

            

                
            

            

                
    return v7;

            

        

            

                6937
            

            

                
            

            

                
}

            

        

            

                6938
            

            

                
            

            

                

            

        

            

                6939
            

            

                
            

            

                
// Generated as internal constructor for term fadd.

            

        

            

                6940
            

            

                
            

            

                
pub fn constructor_fadd<C: Context>(ctx: &mut C, arg0: Type, arg1: Value, arg2: Value) -> Value {

            

        

            

                6941
            

            

                
            

            

                
    let v4 = &C::value_array_2_ctor(ctx, arg1, arg2);

            

        

            

                6942
            

            

                
            

            

                
    let v5 = InstructionData::Binary {

            

        

            

                6943
            

            

                
            

            

                
        opcode: Opcode::Fadd,

            

        

            

                6944
            

            

                
            

            

                
        args: v4.clone(),

            

        

            

                6945
            

            

                
            

            

                
    };

            

        

            

                6946
            

            

                
            

            

                
    let v6 = C::make_inst_ctor(ctx, arg0, &v5);

            

        

            

                6947
            

            

                
            

            

                
    // Rule at /home/smcdev/zk-client-private/near/target/debug/build/cranelift-codegen-c1a82fb675b6a305/out/clif_opt.isle line 1306.

            

        

            

                6948
            

            

                
            

            

                
    return v6;

            

        

            

                6949
            

            

                
            

            

                
}

            

        

            

                6950
            

            

                
            

            

                

            

        

            

                6951
            

            

                
            

            

                
// Generated as internal constructor for term fsub.

            

        

            

                6952
            

            

                
            

            

                
pub fn constructor_fsub<C: Context>(ctx: &mut C, arg0: Type, arg1: Value, arg2: Value) -> Value {

            

        

            

                6953
            

            

                
            

            

                
    let v4 = &C::value_array_2_ctor(ctx, arg1, arg2);

            

        

            

                6954
            

            

                
            

            

                
    let v5 = InstructionData::Binary {

            

        

            

                6955
            

            

                
            

            

                
        opcode: Opcode::Fsub,

            

        

            

                6956
            

            

                
            

            

                
        args: v4.clone(),

            

        

            

                6957
            

            

                
            

            

                
    };

            

        

            

                6958
            

            

                
            

            

                
    let v6 = C::make_inst_ctor(ctx, arg0, &v5);

            

        

            

                6959
            

            

                
            

            

                
    // Rule at /home/smcdev/zk-client-private/near/target/debug/build/cranelift-codegen-c1a82fb675b6a305/out/clif_opt.isle line 1315.

            

        

            

                6960
            

            

                
            

            

                
    return v6;

            

        

            

                6961
            

            

                
            

            

                
}

            

        

            

                6962
            

            

                
            

            

                

            

        

            

                6963
            

            

                
            

            

                
// Generated as internal constructor for term fmul.

            

        

            

                6964
            

            

                
            

            

                
pub fn constructor_fmul<C: Context>(ctx: &mut C, arg0: Type, arg1: Value, arg2: Value) -> Value {

            

        

            

                6965
            

            

                
            

            

                
    let v4 = &C::value_array_2_ctor(ctx, arg1, arg2);

            

        

            

                6966
            

            

                
            

            

                
    let v5 = InstructionData::Binary {

            

        

            

                6967
            

            

                
            

            

                
        opcode: Opcode::Fmul,

            

        

            

                6968
            

            

                
            

            

                
        args: v4.clone(),

            

        

            

                6969
            

            

                
            

            

                
    };

            

        

            

                6970
            

            

                
            

            

                
    let v6 = C::make_inst_ctor(ctx, arg0, &v5);

            

        

            

                6971
            

            

                
            

            

                
    // Rule at /home/smcdev/zk-client-private/near/target/debug/build/cranelift-codegen-c1a82fb675b6a305/out/clif_opt.isle line 1324.

            

        

            

                6972
            

            

                
            

            

                
    return v6;

            

        

            

                6973
            

            

                
            

            

                
}

            

        

            

                6974
            

            

                
            

            

                

            

        

            

                6975
            

            

                
            

            

                
// Generated as internal constructor for term fdiv.

            

        

            

                6976
            

            

                
            

            

                
pub fn constructor_fdiv<C: Context>(ctx: &mut C, arg0: Type, arg1: Value, arg2: Value) -> Value {

            

        

            

                6977
            

            

                
            

            

                
    let v4 = &C::value_array_2_ctor(ctx, arg1, arg2);

            

        

            

                6978
            

            

                
            

            

                
    let v5 = InstructionData::Binary {

            

        

            

                6979
            

            

                
            

            

                
        opcode: Opcode::Fdiv,

            

        

            

                6980
            

            

                
            

            

                
        args: v4.clone(),

            

        

            

                6981
            

            

                
            

            

                
    };

            

        

            

                6982
            

            

                
            

            

                
    let v6 = C::make_inst_ctor(ctx, arg0, &v5);

            

        

            

                6983
            

            

                
            

            

                
    // Rule at /home/smcdev/zk-client-private/near/target/debug/build/cranelift-codegen-c1a82fb675b6a305/out/clif_opt.isle line 1333.

            

        

            

                6984
            

            

                
            

            

                
    return v6;

            

        

            

                6985
            

            

                
            

            

                
}

            

        

            

                6986
            

            

                
            

            

                

            

        

            

                6987
            

            

                
            

            

                
// Generated as internal constructor for term sqrt.

            

        

            

                6988
            

            

                
            

            

                
pub fn constructor_sqrt<C: Context>(ctx: &mut C, arg0: Type, arg1: Value) -> Value {

            

        

            

                6989
            

            

                
            

            

                
    let v3 = InstructionData::Unary {

            

        

            

                6990
            

            

                
            

            

                
        opcode: Opcode::Sqrt,

            

        

            

                6991
            

            

                
            

            

                
        arg: arg1,

            

        

            

                6992
            

            

                
            

            

                
    };

            

        

            

                6993
            

            

                
            

            

                
    let v4 = C::make_inst_ctor(ctx, arg0, &v3);

            

        

            

                6994
            

            

                
            

            

                
    // Rule at /home/smcdev/zk-client-private/near/target/debug/build/cranelift-codegen-c1a82fb675b6a305/out/clif_opt.isle line 1342.

            

        

            

                6995
            

            

                
            

            

                
    return v4;

            

        

            

                6996
            

            

                
            

            

                
}

            

        

            

                6997
            

            

                
            

            

                

            

        

            

                6998
            

            

                
            

            

                
// Generated as internal constructor for term fma.

            

        

            

                6999
            

            

                
            

            

                
pub fn constructor_fma<C: Context>(

            

        

            

                7000
            

            

                
            

            

                
    ctx: &mut C,

            

        

            

                7001
            

            

                
            

            

                
    arg0: Type,

            

        

            

                7002
            

            

                
            

            

                
    arg1: Value,

            

        

            

                7003
            

            

                
            

            

                
    arg2: Value,

            

        

            

                7004
            

            

                
            

            

                
    arg3: Value,

            

        

            

                7005
            

            

                
            

            

                
) -> Value {

            

        

            

                7006
            

            

                
            

            

                
    let v5 = &C::value_array_3_ctor(ctx, arg1, arg2, arg3);

            

        

            

                7007
            

            

                
            

            

                
    let v6 = InstructionData::Ternary {

            

        

            

                7008
            

            

                
            

            

                
        opcode: Opcode::Fma,

            

        

            

                7009
            

            

                
            

            

                
        args: v5.clone(),

            

        

            

                7010
            

            

                
            

            

                
    };

            

        

            

                7011
            

            

                
            

            

                
    let v7 = C::make_inst_ctor(ctx, arg0, &v6);

            

        

            

                7012
            

            

                
            

            

                
    // Rule at /home/smcdev/zk-client-private/near/target/debug/build/cranelift-codegen-c1a82fb675b6a305/out/clif_opt.isle line 1351.

            

        

            

                7013
            

            

                
            

            

                
    return v7;

            

        

            

                7014
            

            

                
            

            

                
}

            

        

            

                7015
            

            

                
            

            

                

            

        

            

                7016
            

            

                
            

            

                
// Generated as internal constructor for term fneg.

            

        

            

                7017
            

            

                
            

            

                
pub fn constructor_fneg<C: Context>(ctx: &mut C, arg0: Type, arg1: Value) -> Value {

            

        

            

                7018
            

            

                
            

            

                
    let v3 = InstructionData::Unary {

            

        

            

                7019
            

            

                
            

            

                
        opcode: Opcode::Fneg,

            

        

            

                7020
            

            

                
            

            

                
        arg: arg1,

            

        

            

                7021
            

            

                
            

            

                
    };

            

        

            

                7022
            

            

                
            

            

                
    let v4 = C::make_inst_ctor(ctx, arg0, &v3);

            

        

            

                7023
            

            

                
            

            

                
    // Rule at /home/smcdev/zk-client-private/near/target/debug/build/cranelift-codegen-c1a82fb675b6a305/out/clif_opt.isle line 1360.

            

        

            

                7024
            

            

                
            

            

                
    return v4;

            

        

            

                7025
            

            

                
            

            

                
}

            

        

            

                7026
            

            

                
            

            

                

            

        

            

                7027
            

            

                
            

            

                
// Generated as internal constructor for term fabs.

            

        

            

                7028
            

            

                
            

            

                
pub fn constructor_fabs<C: Context>(ctx: &mut C, arg0: Type, arg1: Value) -> Value {

            

        

            

                7029
            

            

                
            

            

                
    let v3 = InstructionData::Unary {

            

        

            

                7030
            

            

                
            

            

                
        opcode: Opcode::Fabs,

            

        

            

                7031
            

            

                
            

            

                
        arg: arg1,

            

        

            

                7032
            

            

                
            

            

                
    };

            

        

            

                7033
            

            

                
            

            

                
    let v4 = C::make_inst_ctor(ctx, arg0, &v3);

            

        

            

                7034
            

            

                
            

            

                
    // Rule at /home/smcdev/zk-client-private/near/target/debug/build/cranelift-codegen-c1a82fb675b6a305/out/clif_opt.isle line 1369.

            

        

            

                7035
            

            

                
            

            

                
    return v4;

            

        

            

                7036
            

            

                
            

            

                
}

            

        

            

                7037
            

            

                
            

            

                

            

        

            

                7038
            

            

                
            

            

                
// Generated as internal constructor for term fcopysign.

            

        

            

                7039
            

            

                
            

            

                
pub fn constructor_fcopysign<C: Context>(

            

        

            

                7040
            

            

                
            

            

                
    ctx: &mut C,

            

        

            

                7041
            

            

                
            

            

                
    arg0: Type,

            

        

            

                7042
            

            

                
            

            

                
    arg1: Value,

            

        

            

                7043
            

            

                
            

            

                
    arg2: Value,

            

        

            

                7044
            

            

                
            

            

                
) -> Value {

            

        

            

                7045
            

            

                
            

            

                
    let v4 = &C::value_array_2_ctor(ctx, arg1, arg2);

            

        

            

                7046
            

            

                
            

            

                
    let v5 = InstructionData::Binary {

            

        

            

                7047
            

            

                
            

            

                
        opcode: Opcode::Fcopysign,

            

        

            

                7048
            

            

                
            

            

                
        args: v4.clone(),

            

        

            

                7049
            

            

                
            

            

                
    };

            

        

            

                7050
            

            

                
            

            

                
    let v6 = C::make_inst_ctor(ctx, arg0, &v5);

            

        

            

                7051
            

            

                
            

            

                
    // Rule at /home/smcdev/zk-client-private/near/target/debug/build/cranelift-codegen-c1a82fb675b6a305/out/clif_opt.isle line 1378.

            

        

            

                7052
            

            

                
            

            

                
    return v6;

            

        

            

                7053
            

            

                
            

            

                
}

            

        

            

                7054
            

            

                
            

            

                

            

        

            

                7055
            

            

                
            

            

                
// Generated as internal constructor for term fmin.

            

        

            

                7056
            

            

                
            

            

                
pub fn constructor_fmin<C: Context>(ctx: &mut C, arg0: Type, arg1: Value, arg2: Value) -> Value {

            

        

            

                7057
            

            

                
            

            

                
    let v4 = &C::value_array_2_ctor(ctx, arg1, arg2);

            

        

            

                7058
            

            

                
            

            

                
    let v5 = InstructionData::Binary {

            

        

            

                7059
            

            

                
            

            

                
        opcode: Opcode::Fmin,

            

        

            

                7060
            

            

                
            

            

                
        args: v4.clone(),

            

        

            

                7061
            

            

                
            

            

                
    };

            

        

            

                7062
            

            

                
            

            

                
    let v6 = C::make_inst_ctor(ctx, arg0, &v5);

            

        

            

                7063
            

            

                
            

            

                
    // Rule at /home/smcdev/zk-client-private/near/target/debug/build/cranelift-codegen-c1a82fb675b6a305/out/clif_opt.isle line 1387.

            

        

            

                7064
            

            

                
            

            

                
    return v6;

            

        

            

                7065
            

            

                
            

            

                
}

            

        

            

                7066
            

            

                
            

            

                

            

        

            

                7067
            

            

                
            

            

                
// Generated as internal constructor for term fmax.

            

        

            

                7068
            

            

                
            

            

                
pub fn constructor_fmax<C: Context>(ctx: &mut C, arg0: Type, arg1: Value, arg2: Value) -> Value {

            

        

            

                7069
            

            

                
            

            

                
    let v4 = &C::value_array_2_ctor(ctx, arg1, arg2);

            

        

            

                7070
            

            

                
            

            

                
    let v5 = InstructionData::Binary {

            

        

            

                7071
            

            

                
            

            

                
        opcode: Opcode::Fmax,

            

        

            

                7072
            

            

                
            

            

                
        args: v4.clone(),

            

        

            

                7073
            

            

                
            

            

                
    };

            

        

            

                7074
            

            

                
            

            

                
    let v6 = C::make_inst_ctor(ctx, arg0, &v5);

            

        

            

                7075
            

            

                
            

            

                
    // Rule at /home/smcdev/zk-client-private/near/target/debug/build/cranelift-codegen-c1a82fb675b6a305/out/clif_opt.isle line 1396.

            

        

            

                7076
            

            

                
            

            

                
    return v6;

            

        

            

                7077
            

            

                
            

            

                
}

            

        

            

                7078
            

            

                
            

            

                

            

        

            

                7079
            

            

                
            

            

                
// Generated as internal constructor for term ceil.

            

        

            

                7080
            

            

                
            

            

                
pub fn constructor_ceil<C: Context>(ctx: &mut C, arg0: Type, arg1: Value) -> Value {

            

        

            

                7081
            

            

                
            

            

                
    let v3 = InstructionData::Unary {

            

        

            

                7082
            

            

                
            

            

                
        opcode: Opcode::Ceil,

            

        

            

                7083
            

            

                
            

            

                
        arg: arg1,

            

        

            

                7084
            

            

                
            

            

                
    };

            

        

            

                7085
            

            

                
            

            

                
    let v4 = C::make_inst_ctor(ctx, arg0, &v3);

            

        

            

                7086
            

            

                
            

            

                
    // Rule at /home/smcdev/zk-client-private/near/target/debug/build/cranelift-codegen-c1a82fb675b6a305/out/clif_opt.isle line 1405.

            

        

            

                7087
            

            

                
            

            

                
    return v4;

            

        

            

                7088
            

            

                
            

            

                
}

            

        

            

                7089
            

            

                
            

            

                

            

        

            

                7090
            

            

                
            

            

                
// Generated as internal constructor for term floor.

            

        

            

                7091
            

            

                
            

            

                
pub fn constructor_floor<C: Context>(ctx: &mut C, arg0: Type, arg1: Value) -> Value {

            

        

            

                7092
            

            

                
            

            

                
    let v3 = InstructionData::Unary {

            

        

            

                7093
            

            

                
            

            

                
        opcode: Opcode::Floor,

            

        

            

                7094
            

            

                
            

            

                
        arg: arg1,

            

        

            

                7095
            

            

                
            

            

                
    };

            

        

            

                7096
            

            

                
            

            

                
    let v4 = C::make_inst_ctor(ctx, arg0, &v3);

            

        

            

                7097
            

            

                
            

            

                
    // Rule at /home/smcdev/zk-client-private/near/target/debug/build/cranelift-codegen-c1a82fb675b6a305/out/clif_opt.isle line 1414.

            

        

            

                7098
            

            

                
            

            

                
    return v4;

            

        

            

                7099
            

            

                
            

            

                
}

            

        

            

                7100
            

            

                
            

            

                

            

        

            

                7101
            

            

                
            

            

                
// Generated as internal constructor for term trunc.

            

        

            

                7102
            

            

                
            

            

                
pub fn constructor_trunc<C: Context>(ctx: &mut C, arg0: Type, arg1: Value) -> Value {

            

        

            

                7103
            

            

                
            

            

                
    let v3 = InstructionData::Unary {

            

        

            

                7104
            

            

                
            

            

                
        opcode: Opcode::Trunc,

            

        

            

                7105
            

            

                
            

            

                
        arg: arg1,

            

        

            

                7106
            

            

                
            

            

                
    };

            

        

            

                7107
            

            

                
            

            

                
    let v4 = C::make_inst_ctor(ctx, arg0, &v3);

            

        

            

                7108
            

            

                
            

            

                
    // Rule at /home/smcdev/zk-client-private/near/target/debug/build/cranelift-codegen-c1a82fb675b6a305/out/clif_opt.isle line 1423.

            

        

            

                7109
            

            

                
            

            

                
    return v4;

            

        

            

                7110
            

            

                
            

            

                
}

            

        

            

                7111
            

            

                
            

            

                

            

        

            

                7112
            

            

                
            

            

                
// Generated as internal constructor for term nearest.

            

        

            

                7113
            

            

                
            

            

                
pub fn constructor_nearest<C: Context>(ctx: &mut C, arg0: Type, arg1: Value) -> Value {

            

        

            

                7114
            

            

                
            

            

                
    let v3 = InstructionData::Unary {

            

        

            

                7115
            

            

                
            

            

                
        opcode: Opcode::Nearest,

            

        

            

                7116
            

            

                
            

            

                
        arg: arg1,

            

        

            

                7117
            

            

                
            

            

                
    };

            

        

            

                7118
            

            

                
            

            

                
    let v4 = C::make_inst_ctor(ctx, arg0, &v3);

            

        

            

                7119
            

            

                
            

            

                
    // Rule at /home/smcdev/zk-client-private/near/target/debug/build/cranelift-codegen-c1a82fb675b6a305/out/clif_opt.isle line 1432.

            

        

            

                7120
            

            

                
            

            

                
    return v4;

            

        

            

                7121
            

            

                
            

            

                
}

            

        

            

                7122
            

            

                
            

            

                

            

        

            

                7123
            

            

                
            

            

                
// Generated as internal constructor for term is_null.

            

        

            

                7124
            

            

                
            

            

                
pub fn constructor_is_null<C: Context>(ctx: &mut C, arg0: Type, arg1: Value) -> Value {

            

        

            

                7125
            

            

                
            

            

                
    let v3 = InstructionData::Unary {

            

        

            

                7126
            

            

                
            

            

                
        opcode: Opcode::IsNull,

            

        

            

                7127
            

            

                
            

            

                
        arg: arg1,

            

        

            

                7128
            

            

                
            

            

                
    };

            

        

            

                7129
            

            

                
            

            

                
    let v4 = C::make_inst_ctor(ctx, arg0, &v3);

            

        

            

                7130
            

            

                
            

            

                
    // Rule at /home/smcdev/zk-client-private/near/target/debug/build/cranelift-codegen-c1a82fb675b6a305/out/clif_opt.isle line 1441.

            

        

            

                7131
            

            

                
            

            

                
    return v4;

            

        

            

                7132
            

            

                
            

            

                
}

            

        

            

                7133
            

            

                
            

            

                

            

        

            

                7134
            

            

                
            

            

                
// Generated as internal constructor for term is_invalid.

            

        

            

                7135
            

            

                
            

            

                
pub fn constructor_is_invalid<C: Context>(ctx: &mut C, arg0: Type, arg1: Value) -> Value {

            

        

            

                7136
            

            

                
            

            

                
    let v3 = InstructionData::Unary {

            

        

            

                7137
            

            

                
            

            

                
        opcode: Opcode::IsInvalid,

            

        

            

                7138
            

            

                
            

            

                
        arg: arg1,

            

        

            

                7139
            

            

                
            

            

                
    };

            

        

            

                7140
            

            

                
            

            

                
    let v4 = C::make_inst_ctor(ctx, arg0, &v3);

            

        

            

                7141
            

            

                
            

            

                
    // Rule at /home/smcdev/zk-client-private/near/target/debug/build/cranelift-codegen-c1a82fb675b6a305/out/clif_opt.isle line 1450.

            

        

            

                7142
            

            

                
            

            

                
    return v4;

            

        

            

                7143
            

            

                
            

            

                
}

            

        

            

                7144
            

            

                
            

            

                

            

        

            

                7145
            

            

                
            

            

                
// Generated as internal constructor for term bitcast.

            

        

            

                7146
            

            

                
            

            

                
pub fn constructor_bitcast<C: Context>(

            

        

            

                7147
            

            

                
            

            

                
    ctx: &mut C,

            

        

            

                7148
            

            

                
            

            

                
    arg0: Type,

            

        

            

                7149
            

            

                
            

            

                
    arg1: MemFlags,

            

        

            

                7150
            

            

                
            

            

                
    arg2: Value,

            

        

            

                7151
            

            

                
            

            

                
) -> Value {

            

        

            

                7152
            

            

                
            

            

                
    let v4 = InstructionData::LoadNoOffset {

            

        

            

                7153
            

            

                
            

            

                
        opcode: Opcode::Bitcast,

            

        

            

                7154
            

            

                
            

            

                
        arg: arg2,

            

        

            

                7155
            

            

                
            

            

                
        flags: arg1,

            

        

            

                7156
            

            

                
            

            

                
    };

            

        

            

                7157
            

            

                
            

            

                
    let v5 = C::make_inst_ctor(ctx, arg0, &v4);

            

        

            

                7158
            

            

                
            

            

                
    // Rule at /home/smcdev/zk-client-private/near/target/debug/build/cranelift-codegen-c1a82fb675b6a305/out/clif_opt.isle line 1459.

            

        

            

                7159
            

            

                
            

            

                
    return v5;

            

        

            

                7160
            

            

                
            

            

                
}

            

        

            

                7161
            

            

                
            

            

                

            

        

            

                7162
            

            

                
            

            

                
// Generated as internal constructor for term scalar_to_vector.

            

        

            

                7163
            

            

                
            

            

                
pub fn constructor_scalar_to_vector<C: Context>(ctx: &mut C, arg0: Type, arg1: Value) -> Value {

            

        

            

                7164
            

            

                
            

            

                
    let v3 = InstructionData::Unary {

            

        

            

                7165
            

            

                
            

            

                
        opcode: Opcode::ScalarToVector,

            

        

            

                7166
            

            

                
            

            

                
        arg: arg1,

            

        

            

                7167
            

            

                
            

            

                
    };

            

        

            

                7168
            

            

                
            

            

                
    let v4 = C::make_inst_ctor(ctx, arg0, &v3);

            

        

            

                7169
            

            

                
            

            

                
    // Rule at /home/smcdev/zk-client-private/near/target/debug/build/cranelift-codegen-c1a82fb675b6a305/out/clif_opt.isle line 1468.

            

        

            

                7170
            

            

                
            

            

                
    return v4;

            

        

            

                7171
            

            

                
            

            

                
}

            

        

            

                7172
            

            

                
            

            

                

            

        

            

                7173
            

            

                
            

            

                
// Generated as internal constructor for term bmask.

            

        

            

                7174
            

            

                
            

            

                
pub fn constructor_bmask<C: Context>(ctx: &mut C, arg0: Type, arg1: Value) -> Value {

            

        

            

                7175
            

            

                
            

            

                
    let v3 = InstructionData::Unary {

            

        

            

                7176
            

            

                
            

            

                
        opcode: Opcode::Bmask,

            

        

            

                7177
            

            

                
            

            

                
        arg: arg1,

            

        

            

                7178
            

            

                
            

            

                
    };

            

        

            

                7179
            

            

                
            

            

                
    let v4 = C::make_inst_ctor(ctx, arg0, &v3);

            

        

            

                7180
            

            

                
            

            

                
    // Rule at /home/smcdev/zk-client-private/near/target/debug/build/cranelift-codegen-c1a82fb675b6a305/out/clif_opt.isle line 1477.

            

        

            

                7181
            

            

                
            

            

                
    return v4;

            

        

            

                7182
            

            

                
            

            

                
}

            

        

            

                7183
            

            

                
            

            

                

            

        

            

                7184
            

            

                
            

            

                
// Generated as internal constructor for term ireduce.

            

        

            

                7185
            

            

                
            

            

                
pub fn constructor_ireduce<C: Context>(ctx: &mut C, arg0: Type, arg1: Value) -> Value {

            

        

            

                7186
            

            

                
            

            

                
    let v3 = InstructionData::Unary {

            

        

            

                7187
            

            

                
            

            

                
        opcode: Opcode::Ireduce,

            

        

            

                7188
            

            

                
            

            

                
        arg: arg1,

            

        

            

                7189
            

            

                
            

            

                
    };

            

        

            

                7190
            

            

                
            

            

                
    let v4 = C::make_inst_ctor(ctx, arg0, &v3);

            

        

            

                7191
            

            

                
            

            

                
    // Rule at /home/smcdev/zk-client-private/near/target/debug/build/cranelift-codegen-c1a82fb675b6a305/out/clif_opt.isle line 1486.

            

        

            

                7192
            

            

                
            

            

                
    return v4;

            

        

            

                7193
            

            

                
            

            

                
}

            

        

            

                7194
            

            

                
            

            

                

            

        

            

                7195
            

            

                
            

            

                
// Generated as internal constructor for term snarrow.

            

        

            

                7196
            

            

                
            

            

                
pub fn constructor_snarrow<C: Context>(ctx: &mut C, arg0: Type, arg1: Value, arg2: Value) -> Value {

            

        

            

                7197
            

            

                
            

            

                
    let v4 = &C::value_array_2_ctor(ctx, arg1, arg2);

            

        

            

                7198
            

            

                
            

            

                
    let v5 = InstructionData::Binary {

            

        

            

                7199
            

            

                
            

            

                
        opcode: Opcode::Snarrow,

            

        

            

                7200
            

            

                
            

            

                
        args: v4.clone(),

            

        

            

                7201
            

            

                
            

            

                
    };

            

        

            

                7202
            

            

                
            

            

                
    let v6 = C::make_inst_ctor(ctx, arg0, &v5);

            

        

            

                7203
            

            

                
            

            

                
    // Rule at /home/smcdev/zk-client-private/near/target/debug/build/cranelift-codegen-c1a82fb675b6a305/out/clif_opt.isle line 1495.

            

        

            

                7204
            

            

                
            

            

                
    return v6;

            

        

            

                7205
            

            

                
            

            

                
}

            

        

            

                7206
            

            

                
            

            

                

            

        

            

                7207
            

            

                
            

            

                
// Generated as internal constructor for term unarrow.

            

        

            

                7208
            

            

                
            

            

                
pub fn constructor_unarrow<C: Context>(ctx: &mut C, arg0: Type, arg1: Value, arg2: Value) -> Value {

            

        

            

                7209
            

            

                
            

            

                
    let v4 = &C::value_array_2_ctor(ctx, arg1, arg2);

            

        

            

                7210
            

            

                
            

            

                
    let v5 = InstructionData::Binary {

            

        

            

                7211
            

            

                
            

            

                
        opcode: Opcode::Unarrow,

            

        

            

                7212
            

            

                
            

            

                
        args: v4.clone(),

            

        

            

                7213
            

            

                
            

            

                
    };

            

        

            

                7214
            

            

                
            

            

                
    let v6 = C::make_inst_ctor(ctx, arg0, &v5);

            

        

            

                7215
            

            

                
            

            

                
    // Rule at /home/smcdev/zk-client-private/near/target/debug/build/cranelift-codegen-c1a82fb675b6a305/out/clif_opt.isle line 1504.

            

        

            

                7216
            

            

                
            

            

                
    return v6;

            

        

            

                7217
            

            

                
            

            

                
}

            

        

            

                7218
            

            

                
            

            

                

            

        

            

                7219
            

            

                
            

            

                
// Generated as internal constructor for term uunarrow.

            

        

            

                7220
            

            

                
            

            

                
pub fn constructor_uunarrow<C: Context>(

            

        

            

                7221
            

            

                
            

            

                
    ctx: &mut C,

            

        

            

                7222
            

            

                
            

            

                
    arg0: Type,

            

        

            

                7223
            

            

                
            

            

                
    arg1: Value,

            

        

            

                7224
            

            

                
            

            

                
    arg2: Value,

            

        

            

                7225
            

            

                
            

            

                
) -> Value {

            

        

            

                7226
            

            

                
            

            

                
    let v4 = &C::value_array_2_ctor(ctx, arg1, arg2);

            

        

            

                7227
            

            

                
            

            

                
    let v5 = InstructionData::Binary {

            

        

            

                7228
            

            

                
            

            

                
        opcode: Opcode::Uunarrow,

            

        

            

                7229
            

            

                
            

            

                
        args: v4.clone(),

            

        

            

                7230
            

            

                
            

            

                
    };

            

        

            

                7231
            

            

                
            

            

                
    let v6 = C::make_inst_ctor(ctx, arg0, &v5);

            

        

            

                7232
            

            

                
            

            

                
    // Rule at /home/smcdev/zk-client-private/near/target/debug/build/cranelift-codegen-c1a82fb675b6a305/out/clif_opt.isle line 1513.

            

        

            

                7233
            

            

                
            

            

                
    return v6;

            

        

            

                7234
            

            

                
            

            

                
}

            

        

            

                7235
            

            

                
            

            

                

            

        

            

                7236
            

            

                
            

            

                
// Generated as internal constructor for term swiden_low.

            

        

            

                7237
            

            

                
            

            

                
pub fn constructor_swiden_low<C: Context>(ctx: &mut C, arg0: Type, arg1: Value) -> Value {

            

        

            

                7238
            

            

                
            

            

                
    let v3 = InstructionData::Unary {

            

        

            

                7239
            

            

                
            

            

                
        opcode: Opcode::SwidenLow,

            

        

            

                7240
            

            

                
            

            

                
        arg: arg1,

            

        

            

                7241
            

            

                
            

            

                
    };

            

        

            

                7242
            

            

                
            

            

                
    let v4 = C::make_inst_ctor(ctx, arg0, &v3);

            

        

            

                7243
            

            

                
            

            

                
    // Rule at /home/smcdev/zk-client-private/near/target/debug/build/cranelift-codegen-c1a82fb675b6a305/out/clif_opt.isle line 1522.

            

        

            

                7244
            

            

                
            

            

                
    return v4;

            

        

            

                7245
            

            

                
            

            

                
}

            

        

            

                7246
            

            

                
            

            

                

            

        

            

                7247
            

            

                
            

            

                
// Generated as internal constructor for term swiden_high.

            

        

            

                7248
            

            

                
            

            

                
pub fn constructor_swiden_high<C: Context>(ctx: &mut C, arg0: Type, arg1: Value) -> Value {

            

        

            

                7249
            

            

                
            

            

                
    let v3 = InstructionData::Unary {

            

        

            

                7250
            

            

                
            

            

                
        opcode: Opcode::SwidenHigh,

            

        

            

                7251
            

            

                
            

            

                
        arg: arg1,

            

        

            

                7252
            

            

                
            

            

                
    };

            

        

            

                7253
            

            

                
            

            

                
    let v4 = C::make_inst_ctor(ctx, arg0, &v3);

            

        

            

                7254
            

            

                
            

            

                
    // Rule at /home/smcdev/zk-client-private/near/target/debug/build/cranelift-codegen-c1a82fb675b6a305/out/clif_opt.isle line 1531.

            

        

            

                7255
            

            

                
            

            

                
    return v4;

            

        

            

                7256
            

            

                
            

            

                
}

            

        

            

                7257
            

            

                
            

            

                

            

        

            

                7258
            

            

                
            

            

                
// Generated as internal constructor for term uwiden_low.

            

        

            

                7259
            

            

                
            

            

                
pub fn constructor_uwiden_low<C: Context>(ctx: &mut C, arg0: Type, arg1: Value) -> Value {

            

        

            

                7260
            

            

                
            

            

                
    let v3 = InstructionData::Unary {

            

        

            

                7261
            

            

                
            

            

                
        opcode: Opcode::UwidenLow,

            

        

            

                7262
            

            

                
            

            

                
        arg: arg1,

            

        

            

                7263
            

            

                
            

            

                
    };

            

        

            

                7264
            

            

                
            

            

                
    let v4 = C::make_inst_ctor(ctx, arg0, &v3);

            

        

            

                7265
            

            

                
            

            

                
    // Rule at /home/smcdev/zk-client-private/near/target/debug/build/cranelift-codegen-c1a82fb675b6a305/out/clif_opt.isle line 1540.

            

        

            

                7266
            

            

                
            

            

                
    return v4;

            

        

            

                7267
            

            

                
            

            

                
}

            

        

            

                7268
            

            

                
            

            

                

            

        

            

                7269
            

            

                
            

            

                
// Generated as internal constructor for term uwiden_high.

            

        

            

                7270
            

            

                
            

            

                
pub fn constructor_uwiden_high<C: Context>(ctx: &mut C, arg0: Type, arg1: Value) -> Value {

            

        

            

                7271
            

            

                
            

            

                
    let v3 = InstructionData::Unary {

            

        

            

                7272
            

            

                
            

            

                
        opcode: Opcode::UwidenHigh,

            

        

            

                7273
            

            

                
            

            

                
        arg: arg1,

            

        

            

                7274
            

            

                
            

            

                
    };

            

        

            

                7275
            

            

                
            

            

                
    let v4 = C::make_inst_ctor(ctx, arg0, &v3);

            

        

            

                7276
            

            

                
            

            

                
    // Rule at /home/smcdev/zk-client-private/near/target/debug/build/cranelift-codegen-c1a82fb675b6a305/out/clif_opt.isle line 1549.

            

        

            

                7277
            

            

                
            

            

                
    return v4;

            

        

            

                7278
            

            

                
            

            

                
}

            

        

            

                7279
            

            

                
            

            

                

            

        

            

                7280
            

            

                
            

            

                
// Generated as internal constructor for term iadd_pairwise.

            

        

            

                7281
            

            

                
            

            

                
pub fn constructor_iadd_pairwise<C: Context>(

            

        

            

                7282
            

            

                
            

            

                
    ctx: &mut C,

            

        

            

                7283
            

            

                
            

            

                
    arg0: Type,

            

        

            

                7284
            

            

                
            

            

                
    arg1: Value,

            

        

            

                7285
            

            

                
            

            

                
    arg2: Value,

            

        

            

                7286
            

            

                
            

            

                
) -> Value {

            

        

            

                7287
            

            

                
            

            

                
    let v4 = &C::value_array_2_ctor(ctx, arg1, arg2);

            

        

            

                7288
            

            

                
            

            

                
    let v5 = InstructionData::Binary {

            

        

            

                7289
            

            

                
            

            

                
        opcode: Opcode::IaddPairwise,

            

        

            

                7290
            

            

                
            

            

                
        args: v4.clone(),

            

        

            

                7291
            

            

                
            

            

                
    };

            

        

            

                7292
            

            

                
            

            

                
    let v6 = C::make_inst_ctor(ctx, arg0, &v5);

            

        

            

                7293
            

            

                
            

            

                
    // Rule at /home/smcdev/zk-client-private/near/target/debug/build/cranelift-codegen-c1a82fb675b6a305/out/clif_opt.isle line 1558.

            

        

            

                7294
            

            

                
            

            

                
    return v6;

            

        

            

                7295
            

            

                
            

            

                
}

            

        

            

                7296
            

            

                
            

            

                

            

        

            

                7297
            

            

                
            

            

                
// Generated as internal constructor for term x86_pmaddubsw.

            

        

            

                7298
            

            

                
            

            

                
pub fn constructor_x86_pmaddubsw<C: Context>(

            

        

            

                7299
            

            

                
            

            

                
    ctx: &mut C,

            

        

            

                7300
            

            

                
            

            

                
    arg0: Type,

            

        

            

                7301
            

            

                
            

            

                
    arg1: Value,

            

        

            

                7302
            

            

                
            

            

                
    arg2: Value,

            

        

            

                7303
            

            

                
            

            

                
) -> Value {

            

        

            

                7304
            

            

                
            

            

                
    let v4 = &C::value_array_2_ctor(ctx, arg1, arg2);

            

        

            

                7305
            

            

                
            

            

                
    let v5 = InstructionData::Binary {

            

        

            

                7306
            

            

                
            

            

                
        opcode: Opcode::X86Pmaddubsw,

            

        

            

                7307
            

            

                
            

            

                
        args: v4.clone(),

            

        

            

                7308
            

            

                
            

            

                
    };

            

        

            

                7309
            

            

                
            

            

                
    let v6 = C::make_inst_ctor(ctx, arg0, &v5);

            

        

            

                7310
            

            

                
            

            

                
    // Rule at /home/smcdev/zk-client-private/near/target/debug/build/cranelift-codegen-c1a82fb675b6a305/out/clif_opt.isle line 1567.

            

        

            

                7311
            

            

                
            

            

                
    return v6;

            

        

            

                7312
            

            

                
            

            

                
}

            

        

            

                7313
            

            

                
            

            

                

            

        

            

                7314
            

            

                
            

            

                
// Generated as internal constructor for term uextend.

            

        

            

                7315
            

            

                
            

            

                
pub fn constructor_uextend<C: Context>(ctx: &mut C, arg0: Type, arg1: Value) -> Value {

            

        

            

                7316
            

            

                
            

            

                
    let v3 = InstructionData::Unary {

            

        

            

                7317
            

            

                
            

            

                
        opcode: Opcode::Uextend,

            

        

            

                7318
            

            

                
            

            

                
        arg: arg1,

            

        

            

                7319
            

            

                
            

            

                
    };

            

        

            

                7320
            

            

                
            

            

                
    let v4 = C::make_inst_ctor(ctx, arg0, &v3);

            

        

            

                7321
            

            

                
            

            

                
    // Rule at /home/smcdev/zk-client-private/near/target/debug/build/cranelift-codegen-c1a82fb675b6a305/out/clif_opt.isle line 1576.

            

        

            

                7322
            

            

                
            

            

                
    return v4;

            

        

            

                7323
            

            

                
            

            

                
}

            

        

            

                7324
            

            

                
            

            

                

            

        

            

                7325
            

            

                
            

            

                
// Generated as internal constructor for term sextend.

            

        

            

                7326
            

            

                
            

            

                
pub fn constructor_sextend<C: Context>(ctx: &mut C, arg0: Type, arg1: Value) -> Value {

            

        

            

                7327
            

            

                
            

            

                
    let v3 = InstructionData::Unary {

            

        

            

                7328
            

            

                
            

            

                
        opcode: Opcode::Sextend,

            

        

            

                7329
            

            

                
            

            

                
        arg: arg1,

            

        

            

                7330
            

            

                
            

            

                
    };

            

        

            

                7331
            

            

                
            

            

                
    let v4 = C::make_inst_ctor(ctx, arg0, &v3);

            

        

            

                7332
            

            

                
            

            

                
    // Rule at /home/smcdev/zk-client-private/near/target/debug/build/cranelift-codegen-c1a82fb675b6a305/out/clif_opt.isle line 1585.

            

        

            

                7333
            

            

                
            

            

                
    return v4;

            

        

            

                7334
            

            

                
            

            

                
}

            

        

            

                7335
            

            

                
            

            

                

            

        

            

                7336
            

            

                
            

            

                
// Generated as internal constructor for term fpromote.

            

        

            

                7337
            

            

                
            

            

                
pub fn constructor_fpromote<C: Context>(ctx: &mut C, arg0: Type, arg1: Value) -> Value {

            

        

            

                7338
            

            

                
            

            

                
    let v3 = InstructionData::Unary {

            

        

            

                7339
            

            

                
            

            

                
        opcode: Opcode::Fpromote,

            

        

            

                7340
            

            

                
            

            

                
        arg: arg1,

            

        

            

                7341
            

            

                
            

            

                
    };

            

        

            

                7342
            

            

                
            

            

                
    let v4 = C::make_inst_ctor(ctx, arg0, &v3);

            

        

            

                7343
            

            

                
            

            

                
    // Rule at /home/smcdev/zk-client-private/near/target/debug/build/cranelift-codegen-c1a82fb675b6a305/out/clif_opt.isle line 1594.

            

        

            

                7344
            

            

                
            

            

                
    return v4;

            

        

            

                7345
            

            

                
            

            

                
}

            

        

            

                7346
            

            

                
            

            

                

            

        

            

                7347
            

            

                
            

            

                
// Generated as internal constructor for term fdemote.

            

        

            

                7348
            

            

                
            

            

                
pub fn constructor_fdemote<C: Context>(ctx: &mut C, arg0: Type, arg1: Value) -> Value {

            

        

            

                7349
            

            

                
            

            

                
    let v3 = InstructionData::Unary {

            

        

            

                7350
            

            

                
            

            

                
        opcode: Opcode::Fdemote,

            

        

            

                7351
            

            

                
            

            

                
        arg: arg1,

            

        

            

                7352
            

            

                
            

            

                
    };

            

        

            

                7353
            

            

                
            

            

                
    let v4 = C::make_inst_ctor(ctx, arg0, &v3);

            

        

            

                7354
            

            

                
            

            

                
    // Rule at /home/smcdev/zk-client-private/near/target/debug/build/cranelift-codegen-c1a82fb675b6a305/out/clif_opt.isle line 1603.

            

        

            

                7355
            

            

                
            

            

                
    return v4;

            

        

            

                7356
            

            

                
            

            

                
}

            

        

            

                7357
            

            

                
            

            

                

            

        

            

                7358
            

            

                
            

            

                
// Generated as internal constructor for term fvdemote.

            

        

            

                7359
            

            

                
            

            

                
pub fn constructor_fvdemote<C: Context>(ctx: &mut C, arg0: Type, arg1: Value) -> Value {

            

        

            

                7360
            

            

                
            

            

                
    let v3 = InstructionData::Unary {

            

        

            

                7361
            

            

                
            

            

                
        opcode: Opcode::Fvdemote,

            

        

            

                7362
            

            

                
            

            

                
        arg: arg1,

            

        

            

                7363
            

            

                
            

            

                
    };

            

        

            

                7364
            

            

                
            

            

                
    let v4 = C::make_inst_ctor(ctx, arg0, &v3);

            

        

            

                7365
            

            

                
            

            

                
    // Rule at /home/smcdev/zk-client-private/near/target/debug/build/cranelift-codegen-c1a82fb675b6a305/out/clif_opt.isle line 1612.

            

        

            

                7366
            

            

                
            

            

                
    return v4;

            

        

            

                7367
            

            

                
            

            

                
}

            

        

            

                7368
            

            

                
            

            

                

            

        

            

                7369
            

            

                
            

            

                
// Generated as internal constructor for term fvpromote_low.

            

        

            

                7370
            

            

                
            

            

                
pub fn constructor_fvpromote_low<C: Context>(ctx: &mut C, arg0: Type, arg1: Value) -> Value {

            

        

            

                7371
            

            

                
            

            

                
    let v3 = InstructionData::Unary {

            

        

            

                7372
            

            

                
            

            

                
        opcode: Opcode::FvpromoteLow,

            

        

            

                7373
            

            

                
            

            

                
        arg: arg1,

            

        

            

                7374
            

            

                
            

            

                
    };

            

        

            

                7375
            

            

                
            

            

                
    let v4 = C::make_inst_ctor(ctx, arg0, &v3);

            

        

            

                7376
            

            

                
            

            

                
    // Rule at /home/smcdev/zk-client-private/near/target/debug/build/cranelift-codegen-c1a82fb675b6a305/out/clif_opt.isle line 1621.

            

        

            

                7377
            

            

                
            

            

                
    return v4;

            

        

            

                7378
            

            

                
            

            

                
}

            

        

            

                7379
            

            

                
            

            

                

            

        

            

                7380
            

            

                
            

            

                
// Generated as internal constructor for term fcvt_to_uint.

            

        

            

                7381
            

            

                
            

            

                
pub fn constructor_fcvt_to_uint<C: Context>(ctx: &mut C, arg0: Type, arg1: Value) -> Value {

            

        

            

                7382
            

            

                
            

            

                
    let v3 = InstructionData::Unary {

            

        

            

                7383
            

            

                
            

            

                
        opcode: Opcode::FcvtToUint,

            

        

            

                7384
            

            

                
            

            

                
        arg: arg1,

            

        

            

                7385
            

            

                
            

            

                
    };

            

        

            

                7386
            

            

                
            

            

                
    let v4 = C::make_inst_ctor(ctx, arg0, &v3);

            

        

            

                7387
            

            

                
            

            

                
    // Rule at /home/smcdev/zk-client-private/near/target/debug/build/cranelift-codegen-c1a82fb675b6a305/out/clif_opt.isle line 1630.

            

        

            

                7388
            

            

                
            

            

                
    return v4;

            

        

            

                7389
            

            

                
            

            

                
}

            

        

            

                7390
            

            

                
            

            

                

            

        

            

                7391
            

            

                
            

            

                
// Generated as internal constructor for term fcvt_to_sint.

            

        

            

                7392
            

            

                
            

            

                
pub fn constructor_fcvt_to_sint<C: Context>(ctx: &mut C, arg0: Type, arg1: Value) -> Value {

            

        

            

                7393
            

            

                
            

            

                
    let v3 = InstructionData::Unary {

            

        

            

                7394
            

            

                
            

            

                
        opcode: Opcode::FcvtToSint,

            

        

            

                7395
            

            

                
            

            

                
        arg: arg1,

            

        

            

                7396
            

            

                
            

            

                
    };

            

        

            

                7397
            

            

                
            

            

                
    let v4 = C::make_inst_ctor(ctx, arg0, &v3);

            

        

            

                7398
            

            

                
            

            

                
    // Rule at /home/smcdev/zk-client-private/near/target/debug/build/cranelift-codegen-c1a82fb675b6a305/out/clif_opt.isle line 1639.

            

        

            

                7399
            

            

                
            

            

                
    return v4;

            

        

            

                7400
            

            

                
            

            

                
}

            

        

            

                7401
            

            

                
            

            

                

            

        

            

                7402
            

            

                
            

            

                
// Generated as internal constructor for term fcvt_to_uint_sat.

            

        

            

                7403
            

            

                
            

            

                
pub fn constructor_fcvt_to_uint_sat<C: Context>(ctx: &mut C, arg0: Type, arg1: Value) -> Value {

            

        

            

                7404
            

            

                
            

            

                
    let v3 = InstructionData::Unary {

            

        

            

                7405
            

            

                
            

            

                
        opcode: Opcode::FcvtToUintSat,

            

        

            

                7406
            

            

                
            

            

                
        arg: arg1,

            

        

            

                7407
            

            

                
            

            

                
    };

            

        

            

                7408
            

            

                
            

            

                
    let v4 = C::make_inst_ctor(ctx, arg0, &v3);

            

        

            

                7409
            

            

                
            

            

                
    // Rule at /home/smcdev/zk-client-private/near/target/debug/build/cranelift-codegen-c1a82fb675b6a305/out/clif_opt.isle line 1648.

            

        

            

                7410
            

            

                
            

            

                
    return v4;

            

        

            

                7411
            

            

                
            

            

                
}

            

        

            

                7412
            

            

                
            

            

                

            

        

            

                7413
            

            

                
            

            

                
// Generated as internal constructor for term fcvt_to_sint_sat.

            

        

            

                7414
            

            

                
            

            

                
pub fn constructor_fcvt_to_sint_sat<C: Context>(ctx: &mut C, arg0: Type, arg1: Value) -> Value {

            

        

            

                7415
            

            

                
            

            

                
    let v3 = InstructionData::Unary {

            

        

            

                7416
            

            

                
            

            

                
        opcode: Opcode::FcvtToSintSat,

            

        

            

                7417
            

            

                
            

            

                
        arg: arg1,

            

        

            

                7418
            

            

                
            

            

                
    };

            

        

            

                7419
            

            

                
            

            

                
    let v4 = C::make_inst_ctor(ctx, arg0, &v3);

            

        

            

                7420
            

            

                
            

            

                
    // Rule at /home/smcdev/zk-client-private/near/target/debug/build/cranelift-codegen-c1a82fb675b6a305/out/clif_opt.isle line 1657.

            

        

            

                7421
            

            

                
            

            

                
    return v4;

            

        

            

                7422
            

            

                
            

            

                
}

            

        

            

                7423
            

            

                
            

            

                

            

        

            

                7424
            

            

                
            

            

                
// Generated as internal constructor for term x86_cvtt2dq.

            

        

            

                7425
            

            

                
            

            

                
pub fn constructor_x86_cvtt2dq<C: Context>(ctx: &mut C, arg0: Type, arg1: Value) -> Value {

            

        

            

                7426
            

            

                
            

            

                
    let v3 = InstructionData::Unary {

            

        

            

                7427
            

            

                
            

            

                
        opcode: Opcode::X86Cvtt2dq,

            

        

            

                7428
            

            

                
            

            

                
        arg: arg1,

            

        

            

                7429
            

            

                
            

            

                
    };

            

        

            

                7430
            

            

                
            

            

                
    let v4 = C::make_inst_ctor(ctx, arg0, &v3);

            

        

            

                7431
            

            

                
            

            

                
    // Rule at /home/smcdev/zk-client-private/near/target/debug/build/cranelift-codegen-c1a82fb675b6a305/out/clif_opt.isle line 1666.

            

        

            

                7432
            

            

                
            

            

                
    return v4;

            

        

            

                7433
            

            

                
            

            

                
}

            

        

            

                7434
            

            

                
            

            

                

            

        

            

                7435
            

            

                
            

            

                
// Generated as internal constructor for term fcvt_from_uint.

            

        

            

                7436
            

            

                
            

            

                
pub fn constructor_fcvt_from_uint<C: Context>(ctx: &mut C, arg0: Type, arg1: Value) -> Value {

            

        

            

                7437
            

            

                
            

            

                
    let v3 = InstructionData::Unary {

            

        

            

                7438
            

            

                
            

            

                
        opcode: Opcode::FcvtFromUint,

            

        

            

                7439
            

            

                
            

            

                
        arg: arg1,

            

        

            

                7440
            

            

                
            

            

                
    };

            

        

            

                7441
            

            

                
            

            

                
    let v4 = C::make_inst_ctor(ctx, arg0, &v3);

            

        

            

                7442
            

            

                
            

            

                
    // Rule at /home/smcdev/zk-client-private/near/target/debug/build/cranelift-codegen-c1a82fb675b6a305/out/clif_opt.isle line 1675.

            

        

            

                7443
            

            

                
            

            

                
    return v4;

            

        

            

                7444
            

            

                
            

            

                
}

            

        

            

                7445
            

            

                
            

            

                

            

        

            

                7446
            

            

                
            

            

                
// Generated as internal constructor for term fcvt_from_sint.

            

        

            

                7447
            

            

                
            

            

                
pub fn constructor_fcvt_from_sint<C: Context>(ctx: &mut C, arg0: Type, arg1: Value) -> Value {

            

        

            

                7448
            

            

                
            

            

                
    let v3 = InstructionData::Unary {

            

        

            

                7449
            

            

                
            

            

                
        opcode: Opcode::FcvtFromSint,

            

        

            

                7450
            

            

                
            

            

                
        arg: arg1,

            

        

            

                7451
            

            

                
            

            

                
    };

            

        

            

                7452
            

            

                
            

            

                
    let v4 = C::make_inst_ctor(ctx, arg0, &v3);

            

        

            

                7453
            

            

                
            

            

                
    // Rule at /home/smcdev/zk-client-private/near/target/debug/build/cranelift-codegen-c1a82fb675b6a305/out/clif_opt.isle line 1684.

            

        

            

                7454
            

            

                
            

            

                
    return v4;

            

        

            

                7455
            

            

                
            

            

                
}

            

        

            

                7456
            

            

                
            

            

                

            

        

            

                7457
            

            

                
            

            

                
// Generated as internal constructor for term iconcat.

            

        

            

                7458
            

            

                
            

            

                
pub fn constructor_iconcat<C: Context>(ctx: &mut C, arg0: Type, arg1: Value, arg2: Value) -> Value {

            

        

            

                7459
            

            

                
            

            

                
    let v4 = &C::value_array_2_ctor(ctx, arg1, arg2);

            

        

            

                7460
            

            

                
            

            

                
    let v5 = InstructionData::Binary {

            

        

            

                7461
            

            

                
            

            

                
        opcode: Opcode::Iconcat,

            

        

            

                7462
            

            

                
            

            

                
        args: v4.clone(),

            

        

            

                7463
            

            

                
            

            

                
    };

            

        

            

                7464
            

            

                
            

            

                
    let v6 = C::make_inst_ctor(ctx, arg0, &v5);

            

        

            

                7465
            

            

                
            

            

                
    // Rule at /home/smcdev/zk-client-private/near/target/debug/build/cranelift-codegen-c1a82fb675b6a305/out/clif_opt.isle line 1693.

            

        

            

                7466
            

            

                
            

            

                
    return v6;

            

        

            

                7467
            

            

                
            

            

                
}

            

        

            

                7468
            

            

                
            

            

                

            

        

            

                7469
            

            

                
            

            

                
// Generated as internal constructor for term atomic_rmw.

            

        

            

                7470
            

            

                
            

            

                
pub fn constructor_atomic_rmw<C: Context>(

            

        

            

                7471
            

            

                
            

            

                
    ctx: &mut C,

            

        

            

                7472
            

            

                
            

            

                
    arg0: Type,

            

        

            

                7473
            

            

                
            

            

                
    arg1: MemFlags,

            

        

            

                7474
            

            

                
            

            

                
    arg2: &AtomicRmwOp,

            

        

            

                7475
            

            

                
            

            

                
    arg3: Value,

            

        

            

                7476
            

            

                
            

            

                
    arg4: Value,

            

        

            

                7477
            

            

                
            

            

                
) -> Value {

            

        

            

                7478
            

            

                
            

            

                
    let v6 = &C::value_array_2_ctor(ctx, arg3, arg4);

            

        

            

                7479
            

            

                
            

            

                
    let v7 = InstructionData::AtomicRmw {

            

        

            

                7480
            

            

                
            

            

                
        opcode: Opcode::AtomicRmw,

            

        

            

                7481
            

            

                
            

            

                
        args: v6.clone(),

            

        

            

                7482
            

            

                
            

            

                
        flags: arg1,

            

        

            

                7483
            

            

                
            

            

                
        op: arg2.clone(),

            

        

            

                7484
            

            

                
            

            

                
    };

            

        

            

                7485
            

            

                
            

            

                
    let v8 = C::make_inst_ctor(ctx, arg0, &v7);

            

        

            

                7486
            

            

                
            

            

                
    // Rule at /home/smcdev/zk-client-private/near/target/debug/build/cranelift-codegen-c1a82fb675b6a305/out/clif_opt.isle line 1702.

            

        

            

                7487
            

            

                
            

            

                
    return v8;

            

        

            

                7488
            

            

                
            

            

                
}

            

        

            

                7489
            

            

                
            

            

                

            

        

            

                7490
            

            

                
            

            

                
// Generated as internal constructor for term atomic_cas.

            

        

            

                7491
            

            

                
            

            

                
pub fn constructor_atomic_cas<C: Context>(

            

        

            

                7492
            

            

                
            

            

                
    ctx: &mut C,

            

        

            

                7493
            

            

                
            

            

                
    arg0: Type,

            

        

            

                7494
            

            

                
            

            

                
    arg1: MemFlags,

            

        

            

                7495
            

            

                
            

            

                
    arg2: Value,

            

        

            

                7496
            

            

                
            

            

                
    arg3: Value,

            

        

            

                7497
            

            

                
            

            

                
    arg4: Value,

            

        

            

                7498
            

            

                
            

            

                
) -> Value {

            

        

            

                7499
            

            

                
            

            

                
    let v6 = &C::value_array_3_ctor(ctx, arg2, arg3, arg4);

            

        

            

                7500
            

            

                
            

            

                
    let v7 = InstructionData::AtomicCas {

            

        

            

                7501
            

            

                
            

            

                
        opcode: Opcode::AtomicCas,

            

        

            

                7502
            

            

                
            

            

                
        args: v6.clone(),

            

        

            

                7503
            

            

                
            

            

                
        flags: arg1,

            

        

            

                7504
            

            

                
            

            

                
    };

            

        

            

                7505
            

            

                
            

            

                
    let v8 = C::make_inst_ctor(ctx, arg0, &v7);

            

        

            

                7506
            

            

                
            

            

                
    // Rule at /home/smcdev/zk-client-private/near/target/debug/build/cranelift-codegen-c1a82fb675b6a305/out/clif_opt.isle line 1711.

            

        

            

                7507
            

            

                
            

            

                
    return v8;

            

        

            

                7508
            

            

                
            

            

                
}

            

        

            

                7509
            

            

                
            

            

                

            

        

            

                7510
            

            

                
            

            

                
// Generated as internal constructor for term atomic_load.

            

        

            

                7511
            

            

                
            

            

                
pub fn constructor_atomic_load<C: Context>(

            

        

            

                7512
            

            

                
            

            

                
    ctx: &mut C,

            

        

            

                7513
            

            

                
            

            

                
    arg0: Type,

            

        

            

                7514
            

            

                
            

            

                
    arg1: MemFlags,

            

        

            

                7515
            

            

                
            

            

                
    arg2: Value,

            

        

            

                7516
            

            

                
            

            

                
) -> Value {

            

        

            

                7517
            

            

                
            

            

                
    let v4 = InstructionData::LoadNoOffset {

            

        

            

                7518
            

            

                
            

            

                
        opcode: Opcode::AtomicLoad,

            

        

            

                7519
            

            

                
            

            

                
        arg: arg2,

            

        

            

                7520
            

            

                
            

            

                
        flags: arg1,

            

        

            

                7521
            

            

                
            

            

                
    };

            

        

            

                7522
            

            

                
            

            

                
    let v5 = C::make_inst_ctor(ctx, arg0, &v4);

            

        

            

                7523
            

            

                
            

            

                
    // Rule at /home/smcdev/zk-client-private/near/target/debug/build/cranelift-codegen-c1a82fb675b6a305/out/clif_opt.isle line 1720.

            

        

            

                7524
            

            

                
            

            

                
    return v5;

            

        

            

                7525
            

            

                
            

            

                
}

            

        

            

                7526
            

            

                
            

            

                

            

        

            

                7527
            

            

                
            

            

                
// Generated as internal constructor for term extract_vector.

            

        

            

                7528
            

            

                
            

            

                
pub fn constructor_extract_vector<C: Context>(

            

        

            

                7529
            

            

                
            

            

                
    ctx: &mut C,

            

        

            

                7530
            

            

                
            

            

                
    arg0: Type,

            

        

            

                7531
            

            

                
            

            

                
    arg1: Value,

            

        

            

                7532
            

            

                
            

            

                
    arg2: Uimm8,

            

        

            

                7533
            

            

                
            

            

                
) -> Value {

            

        

            

                7534
            

            

                
            

            

                
    let v4 = InstructionData::BinaryImm8 {

            

        

            

                7535
            

            

                
            

            

                
        opcode: Opcode::ExtractVector,

            

        

            

                7536
            

            

                
            

            

                
        arg: arg1,

            

        

            

                7537
            

            

                
            

            

                
        imm: arg2,

            

        

            

                7538
            

            

                
            

            

                
    };

            

        

            

                7539
            

            

                
            

            

                
    let v5 = C::make_inst_ctor(ctx, arg0, &v4);

            

        

            

                7540
            

            

                
            

            

                
    // Rule at /home/smcdev/zk-client-private/near/target/debug/build/cranelift-codegen-c1a82fb675b6a305/out/clif_opt.isle line 1729.

            

        

            

                7541
            

            

                
            

            

                
    return v5;

            

        

            

                7542
            

            

                
            

            

                
}